MessageQueue.EndReceive(IAsyncResult) Méthode

Définition

Espace de noms:

System.Messaging

Assembly:

System.Messaging.dll

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

C#

public System.Messaging.Message EndReceive (IAsyncResult asyncResult);

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

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

Exceptions

ArgumentNullException

Le paramètre asyncResult a la valeur null.

ArgumentException

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

MessageQueueException

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.

C#

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;
        }
    }
}

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 le déclencheur 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 n’arrive dans la file d’attente, un appel suivant à EndReceive(IAsyncResult) lève une exception.

EndReceive(IAsyncResult) est utilisé pour lire (supprimer de la file d’attente) le message à l’origine du déclenché 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

• BeginReceive()
• ReceiveCompleted