Sdílet prostřednictvím


Gewusst wie: Asynchrones Empfangen von Meldungen

Aktualisiert: November 2007

Sie können Meldungen auf zwei Arten asynchron empfangen: mit einem Ereignishandler zum Empfangen einer Benachrichtigung, wenn die Operation verarbeitet wurde, oder mit einem Rückruf. Eine Übersicht über asynchrone Meldungen finden Sie unter Asynchrone Meldungsverarbeitung.

Bei der Ereignisbenachrichtigung binden Sie zunächst einen Ereignishandler an die Prozedur, die nach Abschluss des asynchronen Aufrufs ausgeführt werden soll. Anschließend rufen Sie die BeginReceive-Methode im Code auf. Damit wird die asynchrone Verarbeitung gestartet, und die Verarbeitung wird an die Komponente zurückgegeben, wenn eine Meldung verfügbar wird oder der Timeout-Parameter abgelaufen ist. Wenn der Aufruf zurückkehrt, führt das System den definierten Delegaten aus und verarbeitet die Abrufergebnisse. Anschließend rufen Sie die EndReceive-Methode auf, um das Ende der Operation anzugeben.

hce32dze.alert_note(de-de,VS.90).gifHinweis:

BeginReceive ruft nur eine einzelne Meldung ab. Wenn Sie Meldungen weiter asynchron verarbeiten möchten, müssen Sie entweder die BeginReceive-Methode erneut aufrufen oder mit dem Rückrufparameter von BeginReceive einen Delegaten aufrufen, der die Warteschlange auf neue Meldungen hin überwacht.

Sie können Meldungen nicht nur asynchron empfangen, sondern auch asynchron einsehen. Das Muster der beiden Prozesse ist sehr ähnlich. Beim asynchronen Einsehen verwenden Sie jedoch die BeginPeek-Methode.

So erstellen Sie das MessageQueue-Objekt programmgesteuert

  1. Fügen Sie dem Projekt einen Verweis auf System.Messaging.dll hinzu.

  2. Erstellen Sie in der implementierten Klasse eine Instanz des MessageQueue-Objekts, und legen Sie seine Path-Eigenschaft (im Konstruktor) und die Formatter-Eigenschaft fest.

    ' 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" });
    

So erstellen Sie das MessageQueue-Objekt im Designer

  1. Fügen Sie dem Projekt einen Verweis auf System.Messaging.dll hinzu.

  2. Ziehen Sie eine MessageQueue-Komponente aus der Toolbox in den Designer. Legen Sie die QueueName-Eigenschaft auf mq fest. Legen Sie die Formatter-Eigenschaft auf XmlMessageFormatter fest. Legen Sie die Path-Eigenschaft auf ".\MyQueue" fest.

So rufen Sie eine Meldung asynchron mit der Ereignisbenachrichtigung ab

  1. Erstellen Sie einen Ereignishandler für das ReceiveCompleted-Ereignis. Doppelklicken Sie im Designer auf die MessageQueue-Komponente, und fügen Sie den unten dargestellten Code hinzu.

    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. Schreiben Sie innerhalb des Ereignishandlers Code zum Abrufen der Meldung. Rufen Sie die Ergebnisse des asynchronen Aufrufs dabei mit dem Message-Objekt ab. Der folgende Code ruft die Meldung ab und zeigt sie in der Konsole an.

    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. Rufen Sie die BeginReceive-Methode an einer Stelle im Code auf, um die asynchrone Operation zu starten. Der folgende Code ruft beispielsweise die Methode auf, wenn der Benutzer auf eine Schaltfläche klickt.

    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. Wenn Sie weiterhin Meldungen asynchron abrufen möchten, rufen Sie die BeginReceive-Methode wie unten dargestellt erneut im ReceiveCompleted-Ereignishandler ab. Damit setzt die Komponente die Verarbeitung neuer Meldungen fort, wenn diese in der Warteschlange empfangen werden.

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

So rufen Sie eine Meldung asynchron mit einem Rückruf ab

  1. Erstellen Sie eine Klasse, die für die Meldungsaufgabe relevante Informationen definiert. Definieren Sie in diesem Fall eine Customer-Klasse.

    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. Erstellen Sie eine Instanz der Klasse. Dieses Objekt wird an die Rückrufmethode übergeben.

    Dim george As New Customer("George")
    
             Customer george = new Customer("George");
    
  3. Erstellen Sie eine Rückrufmethode entsprechend dem AsyncCallback-Delegaten. Diese Methode enthält die Verarbeitung, die nach dem Empfang der Meldung ausgeführt werden muss. Die AsyncState-Eigenschaft des result-Parameters enthält das Objekt, das Sie zur Übergabe der Informationen über die Meldungsaufgabe erstellt haben. In diesem Fall ist AsyncState ein Customer-Objekt.

    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. Rufen Sie die BeginReceive-Methode an einer Stelle im Code auf, um die asynchrone Operation zu starten. Der folgende Code ruft beispielsweise die Methode auf, wenn der Benutzer auf eine Schaltfläche klickt. Eine Meldung wird an die Meldungswarteschlange gesandt und anschließend aus der Warteschlange gelesen. Die oben in Schritt 3 definierte ReceiveCallback-Methode wird aufgerufen, wenn die Meldung empfangen wird.

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

Siehe auch

Aufgaben

Gewusst wie: Einsehen von Meldungen

Gewusst wie: Programmgesteuertes Empfangen von Meldungen

Gewusst wie: Erstellen von Instanzen von MessageQueue-Komponenten

Konzepte

Asynchrone Meldungsverarbeitung

Weitere Ressourcen

Lesen und Empfangen von Meldungen