ReceiveCompletedEventArgs-Klasse

Stellt Daten für das ReceiveCompleted-Ereignis bereit. Beim Aufruf eines Ereignishandlers durch eine asynchrone Receive-Methode wird eine Instanz dieser Klasse an den Handler übergeben.

Namespace: System.Messaging
Assembly: System.Messaging (in system.messaging.dll)

Syntax

'Declaration
Public Class ReceiveCompletedEventArgs
    Inherits EventArgs
'Usage
Dim instance As ReceiveCompletedEventArgs

public class ReceiveCompletedEventArgs : EventArgs

public ref class ReceiveCompletedEventArgs : public EventArgs

public class ReceiveCompletedEventArgs extends EventArgs

public class ReceiveCompletedEventArgs extends EventArgs

Hinweise

Wenn Sie Ereignisbenachrichtigungen zum asynchronen Empfangen von Nachrichten aus einer Warteschlange verwenden, müssen Sie eine Methode erstellen, die die Nachrichtenverarbeitung übernimmt. Zum Starten der asynchronen Verarbeitung muss im Code BeginReceive aufgerufen werden. Nach dem Empfang einer Nachricht wird die Anwendung durch das ReceiveCompleted-Ereignis benachrichtigt. Eine Instanz von ReceiveCompletedEventArgs wird an den Ereignisdelegaten übergeben, der den Ereignishandler aufruft. Die dem ReceiveCompleted-Ereignis zugeordneten Daten sind im AsyncResult-Parameter des Delegaten enthalten.

Es gibt zwei Benachrichtigungsmöglichkeiten bei Abschluss der Ereignisbehandlung: die Ereignisbenachrichtigung und Rückrufe. ReceiveCompletedEventArgs wird nur bei der Ereignisbenachrichtigung verwendet. Weitere Informationen über Rückrufe und die Ereignisbenachrichtigung finden Sie in MSDN unter "Events vs. Callbacks" (nur auf Englisch verfügbar).

ReceiveCompletedEventArgs ermöglicht einen Zugriff auf die Meldung, die den Abschluss der asynchronen Receive-Methode initiiert hat, über den Message-Member. Es handelt sich hierbei um einen alternativen Nachrichtenzugriff (ähnlich einem Aufruf von MessageQueue.EndReceive).

Beispiel

Im folgenden Beispiel wird ein Handler für das ReceiveCompleted-Ereignis erstellt und dem Ereignisdelegaten über ReceiveCompletedEventHandler zugeordnet. Der Ereignishandler MyReceiveCompleted empfängt eine Meldung aus der Warteschlange und gibt deren Text auf dem Bildschirm aus.

Imports System
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 'Main


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

End Class 'MyNewQueue

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

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

package MyProject;

import System.*;
import System.Messaging.*;

/// <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(String[] args)
    {
        // Create an instance of MessageQueue. Set its formatter.
        MessageQueue myQueue = new MessageQueue(".\\myQueue");
        myQueue.set_Formatter(new XmlMessageFormatter(new Type[]
            { String.class.ToType() }));
        // Add an event handler for the ReceiveCompleted event.
        myQueue.add_ReceiveCompleted(new ReceiveCompletedEventHandler
            (MyReceiveCompleted));
        // Begin the asynchronous receive operation.
        myQueue.BeginReceive();
        // Do other work on the current thread.
        return;
    } //main

    //**************************************************
    // 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.get_AsyncResult());
        // Display message information on the screen.
        Console.WriteLine("Message: " + (String)(m.get_Body()));
        // Restart the asynchronous Receive operation.
        mq.BeginReceive();
        return;
    } //MyReceiveCompleted
} //MyNewQueue

Vererbungshierarchie

System.Object
   System.EventArgs
    System.Messaging.ReceiveCompletedEventArgs

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0

Siehe auch

Referenz

ReceiveCompletedEventArgs-Member
System.Messaging-Namespace
MessageQueue-Klasse
ReceiveCompletedEventHandler
MessageQueue.ReceiveCompleted-Ereignis
BeginReceive
EndReceive
Message-Klasse