Comment : recevoir des messages de manière asynchrone

Mise à jour : novembre 2007

Vous pouvez récupérer des messages en mode asynchrone de deux façons : en utilisant un gestionnaire d'événements pour être notifié de la fin du traitement d'une opération ou en recourant à un rappel. Pour une vue d'ensemble de la messagerie asynchrone, consultez Traitement des messages asynchrone.

Dans le cadre de la notification d'événement, commencez par lier un gestionnaire d'événements à la procédure que vous souhaitez exécuter lorsque l'appel asynchrone est terminé. Ensuite, appelez la méthode BeginReceive dans votre code. Le système lance alors le traitement asynchrone et retourne le traitement à votre composant lors de l'arrivée d'un message ou de l'expiration du paramètre d'attente. Lorsque l'appel est retourné, le système exécute le délégué que vous avez défini et traite les résultats de la récupération. Appelez ensuite la méthode EndReceive pour indiquer la fin de l'opération.

Remarque :

BeginReceive ne récupère qu'un seul message. Si vous souhaitez poursuivre le traitement asynchrone des messages, vous devez soit appeler de nouveau la méthode BeginReceive, soit utiliser le paramètre de rappel sur BeginReceive pour appeler un délégué qui continue d'attendre l'arrivée de nouveaux messages dans la file d'attente.

Vous pouvez non seulement recevoir des messages en mode asynchrone, mais également lire des messages en mode asynchrone. Le modèle d'exécution des deux processus est très similaire si ce n'est que, pour lire en mode asynchrone, vous utilisez la méthode BeginPeek.

Pour créer l'objet MessageQueue par programme

  1. Ajoutez à votre projet une référence à System.Messaging.dll.

  2. Créez une instance de l'objet MessageQueue dans la classe que vous implémentez et définissez sa propriété Path (dans le constructeur), ainsi que la propriété Formatter.

    ' Add this to the constructor
Dim targetTypeNames() As String = _
   New String() {"System.String,mscorlib"}
mq.Formatter = _
   New System.Messaging.XmlMessageFormatter(targetTypeNames)

         // Add this to the class declarations.
        System.Messaging.MessageQueue mq =
           new System.Messaging.MessageQueue(".\\MyQueue");
        // Add this to the constructor.
        mq.Formatter = new System.Messaging.XmlMessageFormatter(
           new string[] { "System.String,mscorlib" });

Pour créer l'objet MessageQueue dans le concepteur

  1. Ajoutez à votre projet une référence à System.Messaging.dll.

  2. À partir de la Boîte à outils, faites glisser un composant MessageQueue dans le concepteur. Affectez à la propriété QueueName la valeur mq. Affectez à la propriété Formatter la valeur XmlMessageFormatter. Affectez à la propriété Path la valeur ".\MyQueue".

Pour recevoir un message en mode asynchrone à l'aide de la notification d'événement

  1. Créez un gestionnaire d'événements pour l'événement ReceiveCompleted. Dans le concepteur, double-cliquez sur le composant MessageQueue et ajoutez le code indiqué ci-dessous.

    Private Sub mq_ReceiveCompleted(ByVal sender As System.Object, _
ByVal e As System.Messaging.ReceiveCompletedEventArgs) _
Handles mq.ReceiveCompleted
    ' Add code here to respond to message.
End Sub

         private void mq_ReceiveCompleted(object sender,
        System.Messaging.ReceiveCompletedEventArgs e)
        {
            // Add code here to respond to message.
        }

  2. Écrivez le code dans le gestionnaire d'événements pour récupérer le message, en utilisant l'objet Message pour récupérer les résultats de l'appel asynchrone. Le code ci-dessous récupère le message et l'affiche sur la console.

    Private Sub mq_ReceiveCompleted(ByVal sender As System.Object, _
ByVal e As System.Messaging.ReceiveCompletedEventArgs) _
Handles mq.ReceiveCompleted
    Dim m As System.Messaging.Message = mq.EndReceive(e.AsyncResult)
    m.Formatter = New System.Messaging.XmlMessageFormatter( _
       New String() {"System.String,mscorlib"})
    Console.WriteLine("Message: " + m.Body.ToString())
End Sub

     private void mq_ReceiveCompleted(object sender,
    System.Messaging.ReceiveCompletedEventArgs e)
    {
        System.Messaging.Message m = mq.EndReceive(e.AsyncResult);
        m.Formatter = new System.Messaging.XmlMessageFormatter(
           new string[] { "System.String,mscorlib" });
        Console.WriteLine("Message: " + (string)m.Body);
    }

  3. Appelez la méthode BeginReceive à un endroit du code afin de lancer l'opération asynchrone. Par exemple, le code ci-dessous appelle la méthode lorsque l'utilisateur clique sur un bouton.

    Private Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
    mq.BeginReceive()
End Sub

     private void button1_Click(object sender, System.EventArgs e)
    {
        mq.BeginReceive();
    }

  4. Pour continuer à recevoir des messages en mode asynchrone, appelez de nouveau la méthode BeginReceive dans le gestionnaire d'événements ReceiveCompleted, comme indiqué ci-dessous. Ainsi, votre composant continue à traiter les nouveaux messages à mesure qu'ils arrivent dans la file d'attente.

    Private Sub mq_ReceiveCompleted(ByVal sender As System.Object, _
ByVal e As System.Messaging.ReceiveCompletedEventArgs) _
Handles mq.ReceiveCompleted
    Dim m As System.Messaging.Message = mq.EndReceive(e.AsyncResult)
    m.Formatter = New System.Messaging.XmlMessageFormatter( _
       New String() {"System.String,mscorlib"})
    Console.WriteLine("Message: " + m.Body.ToString())
    mq.BeginReceive()
End Sub

         private void mq_ReceiveCompleted(object sender,
        System.Messaging.ReceiveCompletedEventArgs e)
        {
            System.Messaging.Message m = mq.EndReceive(e.AsyncResult);
            m.Formatter = new System.Messaging.XmlMessageFormatter(
               new string[] { "System.String,mscorlib" });
            Console.WriteLine("Message: " + (string)m.Body);
            mq.BeginReceive();
        }

Pour recevoir un message en mode asynchrone à l'aide d'un rappel

  1. Créez une classe définissant les informations concernant la tâche relative au message. Dans ce cas, définissez une classe Customer.

    Public Class Customer
    Public Name As String = ""
    Public Sub New(ByVal newName As String)
        Name = newName
    End Sub
End Class

     public class Customer
    {
        public string Name = "";
        public Customer(string name)
        {
            Name = name;
        }
    }

  2. Créez une instance de la classe. Cet objet sera passé à la méthode de rappel.

    Dim george As New Customer("George")

             Customer george = new Customer("George");

  3. Créez une méthode de rappel en fonction du délégué AsyncCallback. Cette méthode comprendra le traitement à réaliser une fois le message reçu. La propriété AsyncState du paramètre result contiendra l'objet créé pour passer les informations sur la tâche relative au message. Dans ce cas, AsyncState est un objet Customer.

    Private Sub ReceiveCallback(ByVal result As System.IAsyncResult)
    Dim buyer As Customer = CType(result.AsyncState, Customer)
    Dim buyerName As String = buyer.Name
End Sub

         private void ReceiveCallback(System.IAsyncResult result)
        {
            Customer buyer = (Customer)result.AsyncState;
            string buyerName = buyer.Name;
        }

  4. Appelez la méthode BeginReceive à un endroit du code afin de lancer l'opération asynchrone. Par exemple, le code ci-dessous appelle la méthode lorsque l'utilisateur clique sur un bouton. Un message est envoyé à la file d'attente de messages, puis est lu à partir de cette file d'attente. La méthode ReceiveCallback, définie à l'étape 3 ci-dessus, est appelée à la réception du message.

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
    Handles Button1.Click
    MessageQueue1.Send("Buy six eggs.", george.Name)
    MessageQueue1.BeginReceive(New System.TimeSpan(0, 0, 5), george, _
        AddressOf ReceiveCallback)
End Sub

         private void button1_Click(object sender, System.EventArgs e)
        {
            messageQueue1.Send("Buy six eggs.", george.Name);
            messageQueue1.BeginReceive(new System.TimeSpan(0, 0, 5), george,
                new System.AsyncCallback(this.ReceiveCallback));
        }

Voir aussi

Tâches

Comment : lire des messages

Comment : recevoir des messages par programme

Comment : créer des instances du composant MessageQueue

Concepts

Traitement des messages asynchrone

Autres ressources

Lecture et réception de messages

  • Last updated on