MessageQueue.EndReceive(IAsyncResult) Méthode

Définition

Termine l'opération de réception asynchrone spécifiée.

public:
 System::Messaging::Message ^ EndReceive(IAsyncResult ^ asyncResult);
public System.Messaging.Message EndReceive (IAsyncResult asyncResult);
member this.EndReceive : IAsyncResult -> System.Messaging.Message
Public Function EndReceive (asyncResult As IAsyncResult) As Message

Paramètres

asyncResult
IAsyncResult

IAsyncResult qui identifie l'opération de réception asynchrone à terminer, et à partir de laquelle un résultat final doit être récupéré.

Retours

Message associé à l'opération asynchrone terminée.

Exceptions

Le paramètre asyncResult a la valeur null.

La syntaxe du paramètre asyncResult n'est pas valide.

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant chaîne les requêtes asynchrones. Il suppose qu’il existe une file d’attente sur l’ordinateur local appelée « myQueue ». La Main fonction commence l’opération asynchrone qui est gérée par la MyReceiveCompleted routine. MyReceiveCompleted traite le message actuel et commence une nouvelle opération de réception asynchrone.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Define static class members.
   static ManualResetEvent^ signal = gcnew ManualResetEvent( false );
   static int count = 0;

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );
         count += 1;
         if ( count == 10 )
         {
            signal->Set();
         }

         // Restart the asynchronous receive operation.
         mq->BeginReceive();
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// operation processing.
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Begin the asynchronous receive operation.
   myQueue->BeginReceive();
   MyNewQueue::signal->WaitOne();

   // Do other work on the current thread.
   return 0;
}
using System;
using System.Messaging;
using System.Threading;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {
        // Define static class members.
        static ManualResetEvent signal = new ManualResetEvent(false);
        static int count = 0;

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // operation processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Begin the asynchronous receive operation.
            myQueue.BeginReceive();

            signal.WaitOne();
            
            // Do other work on the current thread.

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
                
                count += 1;
                if (count == 10)
                {
                    signal.Set();
                }

                // Restart the asynchronous receive operation.
                mq.BeginReceive();
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}
Imports System.Messaging
Imports System.Threading




' Provides a container class for the example.

Public Class MyNewQueue

        ' Define static class members.
        Private Shared signal As New ManualResetEvent(False)
        Private Shared count As Integer = 0



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' operation processing.


        Public Shared Sub Main()
            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Begin the asynchronous receive operation.
            myQueue.BeginReceive()

            signal.WaitOne()

            ' Do other work on the current thread.

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = CType([source], MessageQueue)

                ' End the asynchronous receive operation.
                Dim m As Message = _
                    mq.EndReceive(asyncResult.AsyncResult)

                count += 1
                If count = 10 Then
                    signal.Set()
                End If

                ' Restart the asynchronous receive operation.
                mq.BeginReceive()

            Catch
                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Remarques

Lorsque l’événement ReceiveCompleted est déclenché, EndReceive(IAsyncResult) termine l’opération qui a été lancée par l’appel BeginReceive . Pour ce faire, EndReceive(IAsyncResult) reçoit le message.

BeginReceive peut spécifier un délai d’attente, ce qui entraîne la levée de l’événement ReceiveCompleted si le délai d’attente se produit avant qu’un message n’apparaisse dans la file d’attente. Lorsqu’un délai d’attente se produit sans qu’un message arrive dans la file d’attente, un appel suivant à EndReceive(IAsyncResult) lève une exception.

EndReceive(IAsyncResult) est utilisé pour lire (en supprimant de la file d’attente) le message qui a provoqué la levée de l’événement ReceiveCompleted .

Si vous souhaitez continuer à recevoir des messages de manière asynchrone, vous pouvez à nouveau appeler BeginReceive après avoir appelé EndReceive(IAsyncResult).

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail Disponible
Ordinateur local Oui
Ordinateur local et nom de format direct Oui
Ordinateur distant Non
Ordinateur distant et nom de format direct Oui

S’applique à

Voir aussi