ReceiveCompletedEventArgs Klasse

Definition

Stellt Daten für das ReceiveCompleted-Ereignis bereit.Provides data for the ReceiveCompleted event. Beim Aufruf eines Ereignishandlers durch eine asynchrone Receive-Methode wird eine Instanz dieser Klasse an den Handler übergeben.When your asynchronous receive operation calls an event handler, an instance of this class is passed to the handler.

public ref class ReceiveCompletedEventArgs : EventArgs
public class ReceiveCompletedEventArgs : EventArgs
type ReceiveCompletedEventArgs = class
    inherit EventArgs
Public Class ReceiveCompletedEventArgs
Inherits EventArgs
Vererbung
ReceiveCompletedEventArgs

Beispiele

Im folgenden Codebeispiel wird ReceiveCompleted ReceiveCompletedEventHandlerein Ereignishandler für das-Ereignis erstellt und mit dem Ereignis Delegaten verknüpft.The following code example creates an event handler for the ReceiveCompleted event and associates it with the event delegate by using the ReceiveCompletedEventHandler. Der Ereignishandler MyReceiveCompletedempfängt eine Nachricht aus einer Warteschlange und schreibt seinen Text auf den Bildschirm.The event handler, MyReceiveCompleted, receives a message from a queue and writes its body to the screen.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

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

      // End the asynchronous Receive operation.
      Message^ m = mq->EndReceive( asyncResult->AsyncResult );

      // Display message information on the screen.
      Console::WriteLine( "Message: {0}", m->Body );

      // Restart the asynchronous Receive operation.
      mq->BeginReceive();
      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();

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

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // 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();
            
            // Do other work on the current thread.

            return;
        }


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

            // End the asynchronous Receive operation.
            Message m = mq.EndReceive(asyncResult.AsyncResult);

            // Display message information on the screen.
            Console.WriteLine("Message: " + (string)m.Body);

            // Restart the asynchronous Receive operation.
            mq.BeginReceive();
            
            return; 
        }
    }
}
Imports System.Messaging

Public Class MyNewQueue


        '
        ' 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()

            ' 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)

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

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

            ' Display message information on the screen.
            Console.WriteLine(("Message: " + CStr(m.Body)))

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

            Return

        End Sub

End Class

Hinweise

Wenn Sie die Ereignis Benachrichtigung verwenden, um asynchron Nachrichten aus der Warteschlange zu empfangen, müssen Sie eine Methode erstellen, die die Nachrichtenverarbeitung verarbeitet.When you use event notification to receive messages asynchronously from the queue, you must create a method that handles your message processing. Der Code muss aufzurufen BeginReceive , um die asynchrone Verarbeitung zu starten.Your code must call BeginReceive to begin the asynchronous processing. Wenn eine Nachricht empfangen wird, wird die Anwendung über das ReceiveCompleted Ereignis benachrichtigt.When a message is received, your application is notified through the ReceiveCompleted event. Eine Instanz von ReceiveCompletedEventArgs wird an den Ereignis Delegaten, der den Ereignishandler aufruft, übermittelt.An instance of ReceiveCompletedEventArgs is passed into the event delegate that calls your event handler. Die dem ReceiveCompleted Ereignis zugeordneten Daten sind im- AsyncResult Parameter des Delegaten enthalten.The data associated with the ReceiveCompleted event is contained in the delegate's AsyncResult parameter.

Es gibt zwei Möglichkeiten, eine Benachrichtigung über den Abschluss des Ereignisses bereitzustellen: Ereignis Benachrichtigung und Rückrufe.There are two ways to provide notification of event completion: event notification and callbacks. ReceiveCompletedEventArgswird nur bei der Ereignis Benachrichtigung verwendet.ReceiveCompletedEventArgs is used only with event notification. Informationen zum Vergleich von Rückrufen und Ereignis Benachrichtigungen finden Sie unter "Ereignisse im Vergleich zu Rückrufe "auf MSDN.For information comparing callbacks and event notification, see "Events vs. Callbacks" on MSDN.

ReceiveCompletedEventArgsermöglicht den Zugriff auf die Nachricht, die das Ende des asynchronen Empfangs Vorgangs durch den Message -Member initiiert hat.ReceiveCompletedEventArgs provides access to the message that initiated the end of the asynchronous receive operation, through the Message member. Dies ist ein alternativer Zugriff auf die Nachricht und verhält sich ähnlich wie ein Aufrufen von MessageQueue.EndReceive.This is an alternate access to the message, and behaves much the same as a call to MessageQueue.EndReceive.

Eigenschaften

AsyncResult

Ruft das Ergebnis der angeforderten asynchronen Operation ab oder legt dieses fest.Gets or sets the result of the asynchronous operation requested.

Message

Ruft die der asynchronen Receive-Methode zugeordnete Nachricht ab.Gets the message associated with the asynchronous receive operation.

Methoden

Equals(Object)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Geerbt von Object)

Gilt für:

Siehe auch