MessageQueue.BeginReceive Methode

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Gibt zurück

Dies IAsyncResult identifiziert die bereitgestellte asynchrone Anforderung.

Ausnahmen

Beispiele

Im folgenden Codebeispiel werden asynchrone Anforderungen verkettet. Es wird davon ausgegangen, dass auf dem lokalen Computer eine Warteschlange namens "myQueue" vorhanden ist. Die Main Funktion beginnt den asynchronen Vorgang, der von der MyReceiveCompleted Routine behandelt wird. MyReceiveCompleted verarbeitet die aktuelle Nachricht und beginnt einen neuen asynchronen Empfangsvorgang.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Define static class members.
   static ManualResetEvent^ signal = gcnew ManualResetEvent( false );
   static int count = 0;

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

         // End the asynchronous receive operation.
         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;
   }
};

// 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();
   MyNewQueue::signal->WaitOne();

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

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

Imports System.Messaging
Imports System.Threading




' Provides a container class for the example.

Public Class MyNewQueue

        ' Define static class members.
        Private Shared signal As New ManualResetEvent(False)
        Private Shared count As Integer = 0



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

            signal.WaitOne()

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

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

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

                count += 1
                If count = 10 Then
                    signal.Set()
                End If

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

            Catch
                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Im folgenden Codebeispiel werden asynchrone Anforderungen in die Warteschlange gestellt. Der Aufruf, der BeginReceive den AsyncWaitHandle Rückgabewert verwendet. Die Main Routine wartet, bis alle asynchronen Vorgänge abgeschlossen werden, bevor sie beendet werden.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

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

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );

         // Process the message here.
         Console::WriteLine( "Message received." );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }
      // Handle other exceptions.
      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 );

   // Define wait handles for multiple operations.
   array<WaitHandle^>^waitHandleArray = gcnew array<WaitHandle^>(10);
   for ( int i = 0; i < 10; i++ )
   {
      // Begin asynchronous operations.
      waitHandleArray[ i ] = myQueue->BeginReceive()->AsyncWaitHandle;
   }

   // Specify to wait for all operations to return.
   WaitHandle::WaitAll( waitHandleArray );
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

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);
            
            // Define wait handles for multiple operations.
            WaitHandle[] waitHandleArray = new WaitHandle[10];
            for(int i=0; i<10; i++)
            {
                // Begin asynchronous operations.
                waitHandleArray[i] =
                    myQueue.BeginReceive().AsyncWaitHandle;
            }

            // Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray);

            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);
        
                // Process the message here.
                Console.WriteLine("Message received.");
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading


' Provides a container class for the example.

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

            ' Define wait handles for multiple operations.
            Dim waitHandleArray(10) As WaitHandle

            Dim i As Integer
            For i = 0 To 9
                ' Begin asynchronous operations.
                waitHandleArray(i) = _
                    myQueue.BeginReceive().AsyncWaitHandle
            Next i

            ' Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray)

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

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

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

                ' Process the message here.
                Console.WriteLine("Message received.")

            Catch

                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Hinweise

Bei asynchroner Verarbeitung wird BeginReceive das ReceiveCompleted Ereignis ausgelöst, wenn eine Nachricht aus der Warteschlange entfernt wurde.

ReceiveCompleted wird auch ausgelöst, wenn in der Warteschlange bereits eine Nachricht vorhanden ist.

Erstellen Sie zum Verwenden BeginReceiveeinen Ereignishandler, der die Ergebnisse des asynchronen Vorgangs verarbeitet, und ordnen Sie ihn Dem Ereignisdelegat zu. BeginReceive initiiert einen asynchronen Empfangsvorgang; wird MessageQueue über das Auslösen des ReceiveCompleted Ereignisses benachrichtigt, wenn eine Nachricht in der Warteschlange eintrifft. Der MessageQueue Kann dann auf die Nachricht zugreifen, indem sie aufgerufen wird EndReceive(IAsyncResult).

Die BeginReceive Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginReceive es asynchron ist, können Sie sie aufrufen, um eine Nachricht aus der Warteschlange zu empfangen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie die Receive Methode, um eine Nachricht synchron zu empfangen.

Sobald ein asynchroner Vorgang abgeschlossen ist, können Sie im Ereignishandler aufrufen BeginPeek oder BeginReceive erneut, um Benachrichtigungen zu empfangen.

Der IAsyncResult Zurückgegebene BeginReceive gibt den asynchronen Vorgang an, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie sie in der Regel erst verwenden, wenn EndReceive(IAsyncResult) sie aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob alle Vorgänge oder alle Vorgänge abgeschlossen werden sollen. In diesem Fall verwenden Sie die AsyncWaitHandle Eigenschaft der IAsyncResult zum Identifizieren des abgeschlossenen Vorgangs.

Wenn CanRead dies der Fall ist false, wird das Abschlussereignis ausgelöst, aber beim Aufrufen EndReceive(IAsyncResult)wird eine Ausnahme ausgelöst.

Verwenden Sie den asynchronen Aufruf BeginReceive nicht mit Transaktionen. Wenn Sie einen transaktionssynchronen Vorgang ausführen möchten, rufen BeginPeekSie die Transaktion auf, und platzieren Sie die Transaktion und die (synchrone) Receive Methode innerhalb des Ereignishandlers, den Sie für den Vorschauvorgang erstellen. Der Ereignishandler kann Funktionen enthalten, wie im folgenden C#-Code dargestellt.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Weitere Informationen

• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);

public IAsyncResult BeginReceive(TimeSpan timeout);

member this.BeginReceive : TimeSpan -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

Parameter

Gibt zurück

Dies IAsyncResult identifiziert die bereitgestellte asynchrone Anforderung.

Ausnahmen

Beispiele

Im folgenden Codebeispiel wird ein asynchroner Empfangsvorgang erstellt. Im Codebeispiel wird ein Ereignishandler MyReceiveCompletederstellt und an den ReceiveCompleted Ereignishandlerdelegat angefügt. Das Codebeispiel sendet eine Nachricht an eine lokale Nachrichtenwarteschlange und ruft dann einen BeginReceive(TimeSpan)Timeoutwert von zehn Sekunden ab. Wenn ein ReceiveCompleted Ereignis ausgelöst wird, empfängt der Ereignishandler die Nachricht und schreibt den Nachrichtentext auf den Bildschirm.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

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

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        queue = gcnew MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }

    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }

}

using System;
using System.Messaging;

public class QueueExample
{
    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
                ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

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

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Hinweise

Bei asynchroner Verarbeitung wird BeginReceive das ReceiveCompleted Ereignis ausgelöst, wenn eine Nachricht in der Warteschlange verfügbar wird oder wenn das angegebene Zeitintervall abgelaufen ist.

ReceiveCompleted wird auch ausgelöst, wenn in der Warteschlange bereits eine Nachricht vorhanden ist.

Erstellen Sie zum Verwenden BeginReceiveeinen Ereignishandler, der die Ergebnisse des asynchronen Vorgangs verarbeitet, und ordnen Sie ihn Dem Ereignisdelegat zu. BeginReceive initiiert einen asynchronen Empfangsvorgang; wird MessageQueue über das Auslösen des ReceiveCompleted Ereignisses benachrichtigt, wenn eine Nachricht in der Warteschlange eintrifft. Der MessageQueue Zugriff auf die Nachricht erfolgt dann durch Aufrufen EndReceive(IAsyncResult) oder Abrufen des Ergebnisses mithilfe der ReceiveCompletedEventArgs.

Die BeginReceive Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginReceive es asynchron ist, können Sie sie aufrufen, um eine Nachricht aus der Warteschlange zu empfangen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie die Receive Methode, um eine Nachricht synchron zu empfangen.

Sobald ein asynchroner Vorgang abgeschlossen ist, können Sie im Ereignishandler aufrufen BeginPeek oder BeginReceive erneut, um Benachrichtigungen zu empfangen.

Wenn CanRead dies der Fall ist false, wird das Abschlussereignis ausgelöst, aber beim Aufrufen EndReceive(IAsyncResult)wird eine Ausnahme ausgelöst.

Der IAsyncResult Zurückgegebene BeginReceive gibt den asynchronen Vorgang an, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie sie in der Regel erst verwenden, wenn EndReceive(IAsyncResult) sie aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob alle Vorgänge oder alle Vorgänge abgeschlossen werden sollen. In diesem Fall verwenden Sie die AsyncWaitHandle Eigenschaft der IAsyncResult zum Identifizieren des abgeschlossenen Vorgangs.

Diese Überladung gibt einen Timeout an. Wenn das durch den timeout Parameter angegebene Intervall abläuft, löst diese Komponente das ReceiveCompleted Ereignis aus. Da keine Nachricht vorhanden ist, löst ein nachfolgenden Aufruf EndReceive(IAsyncResult) eine Ausnahme aus.

Verwenden Sie den asynchronen Aufruf BeginReceive nicht mit Transaktionen. Wenn Sie einen transaktionssynchronen Vorgang ausführen möchten, rufen BeginPeekSie die Transaktion auf, und platzieren Sie die Transaktion und die (synchrone) Receive Methode innerhalb des Ereignishandlers, den Sie für den Vorschauvorgang erstellen. Der Ereignishandler kann Funktionen enthalten, wie im folgenden C#-Code dargestellt.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Weitere Informationen

• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()
• TimeSpan

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject);

public IAsyncResult BeginReceive(TimeSpan timeout, object stateObject);

member this.BeginReceive : TimeSpan * obj -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan, stateObject As Object) As IAsyncResult

Parameter

Gibt zurück

Dies IAsyncResult identifiziert die bereitgestellte asynchrone Anforderung.

Ausnahmen

Beispiele

Im folgenden Codebeispiel wird ein asynchroner Empfangsvorgang erstellt. Im Codebeispiel wird ein Ereignishandler MyReceiveCompletederstellt und an den ReceiveCompleted Ereignishandlerdelegat angefügt. Das Codebeispiel sendet eine Nachricht an eine lokale Nachrichtenwarteschlange, ruft dann auf BeginReceive(TimeSpan, Object), übergibt einen Timeoutwert von zehn Sekunden und eine eindeutige ganze Zahl, die diese bestimmte Nachricht identifiziert. Wenn ein ReceiveCompleted Ereignis ausgelöst wird, empfängt der Ereignishandler die Nachricht und schreibt den Nachrichtentext und den ganzzahligen Nachrichtenbezeichner auf den Bildschirm.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", e->AsyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;

    // Represents a state object associated with each message.
    int messageNumber = 0;

    try
    {
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        queue = gcnew MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}

using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
            ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

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

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}",
            (int)asyncResult.AsyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Hinweise

Bei asynchroner Verarbeitung wird BeginReceive das ReceiveCompleted Ereignis ausgelöst, wenn eine Nachricht in der Warteschlange verfügbar wird oder wenn das angegebene Zeitintervall abgelaufen ist.

ReceiveCompleted wird auch ausgelöst, wenn in der Warteschlange bereits eine Nachricht vorhanden ist.

Verwenden Sie diese Überladung, um Informationen mit dem Vorgang zu verknüpfen, der während der gesamten Lebensdauer des Vorgangs erhalten bleibt. Der Ereignishandler kann diese Informationen erkennen, indem er die AsyncState Eigenschaft der IAsyncResult dem Vorgang zugeordneten Eigenschaft betrachtet.

Erstellen Sie zum Verwenden BeginReceiveeinen Ereignishandler, der die Ergebnisse des asynchronen Vorgangs verarbeitet, und ordnen Sie ihn Dem Ereignisdelegat zu. BeginReceive initiiert einen asynchronen Empfangsvorgang; wird MessageQueue über das Auslösen des ReceiveCompleted Ereignisses benachrichtigt, wenn eine Nachricht in der Warteschlange eintrifft. Der MessageQueue Zugriff auf die Nachricht erfolgt dann durch Aufrufen EndReceive(IAsyncResult) oder Abrufen des Ergebnisses mithilfe der ReceiveCompletedEventArgs.

Die BeginReceive Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginReceive es asynchron ist, können Sie sie aufrufen, um eine Nachricht aus der Warteschlange zu empfangen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie die Receive Methode, um eine Nachricht synchron zu empfangen.

Sobald ein asynchroner Vorgang abgeschlossen ist, können Sie im Ereignishandler aufrufen BeginPeek oder BeginReceive erneut, um Benachrichtigungen zu empfangen.

Der IAsyncResult Zurückgegebene BeginReceive gibt den asynchronen Vorgang an, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie sie in der Regel erst verwenden, wenn EndReceive(IAsyncResult) sie aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob alle Vorgänge oder alle Vorgänge abgeschlossen werden sollen. In diesem Fall verwenden Sie die AsyncWaitHandle Eigenschaft der IAsyncResult zum Identifizieren des abgeschlossenen Vorgangs.

Diese Überladung gibt ein Timeout und ein Zustandsobjekt an. Wenn das durch den timeout Parameter angegebene Intervall abläuft, löst diese Komponente das ReceiveCompleted Ereignis aus. Da keine Nachricht vorhanden ist, löst ein nachfolgenden Aufruf EndReceive(IAsyncResult) eine Ausnahme aus.

Das Statusobjekt ordnet Statusinformationen dem Vorgang zu. Wenn Sie z. B. mehrere Male aufrufen BeginReceive , um mehrere Vorgänge zu initiieren, können Sie jeden Vorgang über ein separates Zustandsobjekt identifizieren, das Sie definieren.

Sie können auch das Statusobjekt verwenden, um Informationen über Prozessthreads hinweg zu übergeben. Wenn ein Thread gestartet wird, aber sich der Rückruf in einem asynchronen Szenario auf einem anderen Thread befindet, wird das Statusobjekt gemarstet und zusammen mit Informationen aus dem Ereignis übergeben.

Verwenden Sie den asynchronen Aufruf BeginReceive nicht mit Transaktionen. Wenn Sie einen transaktionssynchronen Vorgang ausführen möchten, rufen BeginPeekSie die Transaktion auf, und platzieren Sie die Transaktion und die (synchrone) Receive Methode innerhalb des Ereignishandlers, den Sie für den Vorschauvorgang erstellen. Der Ereignishandler kann Funktionen enthalten, wie im folgenden C#-Code dargestellt.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Weitere Informationen

• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()
• TimeSpan

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);

public IAsyncResult BeginReceive(TimeSpan timeout, object stateObject, AsyncCallback callback);

member this.BeginReceive : TimeSpan * obj * AsyncCallback -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan, stateObject As Object, callback As AsyncCallback) As IAsyncResult

Parameter

Gibt zurück

Dies IAsyncResult identifiziert die bereitgestellte asynchrone Anforderung.

Ausnahmen

Beispiele

Im folgenden Codebeispiel wird ein asynchroner Empfangsvorgang erstellt. Im Codebeispiel wird eine Nachricht an eine lokale Nachrichtenwarteschlange gesendet. Anschließend wird ein Timeoutwert von zehn Sekunden aufgerufenBeginReceive(TimeSpan, Object, AsyncCallback), eine eindeutige ganze Zahl, die diese bestimmte Nachricht identifiziert, und eine neue Instanz, die AsyncCallback den Ereignishandler identifiziert. MyReceiveCompleted Wenn ein ReceiveCompleted Ereignis ausgelöst wird, empfängt der Ereignishandler die Nachricht und schreibt den Nachrichtentext und den ganzzahligen Nachrichtenbezeichner auf den Bildschirm.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if (!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(IAsyncResult^ asyncResult)
{
    // Connect to the queue.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(asyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", asyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Represents a state object associated with each message.
    int messageNumber = 0;

    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        queue = gcnew MessageQueue(".\\exampleQueue");

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++,
            gcnew AsyncCallback(HandleReceiveCompleted));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}

using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++,
            new AsyncCallback(MyReceiveCompleted));
            
        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(IAsyncResult asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}", (int)asyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Hinweise

Wenn Sie diese Überladung verwenden, wird der im Rückrufparameter angegebene Rückruf direkt aufgerufen, wenn eine Nachricht in der Warteschlange verfügbar wird oder wenn das angegebene Zeitintervall abgelaufen ist; das ReceiveCompleted Ereignis wird nicht ausgelöst. Die anderen Überladungen, die BeginReceive von dieser Komponente abhängen, um das ReceiveCompleted Ereignis auszuheben.

ReceiveCompleted wird auch ausgelöst, wenn in der Warteschlange bereits eine Nachricht vorhanden ist.

Erstellen Sie zum Verwenden BeginReceiveeinen Ereignishandler, der die Ergebnisse des asynchronen Vorgangs verarbeitet, und ordnen Sie ihn Dem Ereignisdelegat zu. BeginReceive initiiert einen asynchronen Empfangsvorgang; wird MessageQueue über das Auslösen des ReceiveCompleted Ereignisses benachrichtigt, wenn eine Nachricht in der Warteschlange eintrifft. Der MessageQueue Zugriff auf die Nachricht erfolgt dann durch Aufrufen EndReceive(IAsyncResult) oder Abrufen des Ergebnisses mithilfe der ReceiveCompletedEventArgs.

Die BeginReceive Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginReceive es asynchron ist, können Sie sie aufrufen, um eine Nachricht aus der Warteschlange zu empfangen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie die Receive Methode, um eine Nachricht synchron zu empfangen.

Sobald ein asynchroner Vorgang abgeschlossen ist, können Sie im Ereignishandler aufrufen BeginPeek oder BeginReceive erneut, um Benachrichtigungen zu empfangen.

Der IAsyncResult Zurückgegebene BeginReceive gibt den asynchronen Vorgang an, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie sie in der Regel erst verwenden, wenn EndReceive(IAsyncResult) sie aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob alle Vorgänge oder alle Vorgänge abgeschlossen werden sollen. In diesem Fall verwenden Sie die AsyncWaitHandle Eigenschaft der IAsyncResult zum Identifizieren des abgeschlossenen Vorgangs.

Das Statusobjekt ordnet Statusinformationen dem Vorgang zu. Wenn Sie z. B. mehrere Male aufrufen BeginReceive , um mehrere Vorgänge zu initiieren, können Sie jeden Vorgang über ein separates Zustandsobjekt identifizieren, das Sie definieren.

Sie können auch das Statusobjekt verwenden, um Informationen über Prozessthreads hinweg zu übergeben. Wenn ein Thread gestartet wird, aber sich der Rückruf in einem asynchronen Szenario auf einem anderen Thread befindet, wird das Statusobjekt gemarstet und zusammen mit Informationen aus dem Ereignis übergeben.

Verwenden Sie den asynchronen Aufruf BeginReceive nicht mit Transaktionen. Wenn Sie einen transaktionssynchronen Vorgang ausführen möchten, rufen BeginPeekSie die Transaktion auf, und platzieren Sie die Transaktion und die (synchrone) Receive Methode innerhalb des Ereignishandlers, den Sie für den Vorschauvorgang erstellen. Der Ereignishandler kann Funktionen enthalten, wie im folgenden C#-Code dargestellt.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Weitere Informationen

• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()
• AsyncCallback
• TimeSpan

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Object ^ state, AsyncCallback ^ callback);

public IAsyncResult BeginReceive(TimeSpan timeout, System.Messaging.Cursor cursor, object state, AsyncCallback callback);

member this.BeginReceive : TimeSpan * System.Messaging.Cursor * obj * AsyncCallback -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan, cursor As Cursor, state As Object, callback As AsyncCallback) As IAsyncResult

Parameter

Gibt zurück

Dies IAsyncResult identifiziert die bereitgestellte asynchrone Anforderung.

Ausnahmen

Hinweise

Wenn Sie diese Überladung verwenden, wird der im Rückrufparameter angegebene Rückruf direkt aufgerufen, wenn eine Nachricht in der Warteschlange verfügbar wird oder wenn das angegebene Zeitintervall abgelaufen ist; das ReceiveCompleted Ereignis wird nicht ausgelöst. Die anderen Überladungen, die BeginReceive von dieser Komponente abhängen, um das ReceiveCompleted Ereignis auszuheben.

ReceiveCompleted wird auch ausgelöst, wenn in der Warteschlange bereits eine Nachricht vorhanden ist.

Erstellen Sie zum Verwenden BeginReceiveeinen Ereignishandler, der die Ergebnisse des asynchronen Vorgangs verarbeitet, und ordnen Sie ihn Dem Ereignisdelegat zu. BeginReceive initiiert einen asynchronen Empfangsvorgang; wird MessageQueue über das Auslösen des ReceiveCompleted Ereignisses benachrichtigt, wenn eine Nachricht in der Warteschlange eintrifft. Der MessageQueue Zugriff auf die Nachricht erfolgt dann durch Aufrufen EndReceive(IAsyncResult) oder Abrufen des Ergebnisses mithilfe der ReceiveCompletedEventArgs.

Die BeginReceive Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginReceive es asynchron ist, können Sie sie aufrufen, um eine Nachricht aus der Warteschlange zu empfangen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie die Receive Methode, um eine Nachricht synchron zu empfangen.

Sobald ein asynchroner Vorgang abgeschlossen ist, können Sie im Ereignishandler aufrufen BeginPeek oder BeginReceive erneut, um Benachrichtigungen zu empfangen.

Der IAsyncResult Zurückgegebene BeginReceive gibt den asynchronen Vorgang an, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie sie in der Regel erst verwenden, wenn EndReceive(IAsyncResult) sie aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob alle Vorgänge oder alle Vorgänge abgeschlossen werden sollen. Verwenden Sie in diesem Fall die AsyncWaitHandle Eigenschaft des IAsyncResult abgeschlossenen Vorgangs, um den abgeschlossenen Vorgang zu identifizieren.

Das Statusobjekt ordnet Statusinformationen dem Vorgang zu. Wenn Sie z. B. mehrere Male aufrufen BeginReceive , um mehrere Vorgänge zu initiieren, können Sie jeden Vorgang über ein separates Zustandsobjekt identifizieren, das Sie definieren.

Sie können auch das Statusobjekt verwenden, um Informationen über Prozessthreads hinweg zu übergeben. Wenn ein Thread gestartet wird, aber sich der Rückruf in einem asynchronen Szenario auf einem anderen Thread befindet, wird das Statusobjekt gemarstet und zusammen mit Informationen aus dem Ereignis übergeben.

Verwenden Sie den asynchronen Aufruf BeginReceive nicht mit Transaktionen. Wenn Sie einen transaktionssynchronen Vorgang ausführen möchten, rufen BeginPeekSie die Transaktion auf, und platzieren Sie die Transaktion und die (synchrone) Receive Methode innerhalb des Ereignishandlers, den Sie für den Vorschauvorgang erstellen. Der Ereignishandler kann Funktionen enthalten, wie im folgenden C#-Code dargestellt.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Weitere Informationen

• Cursor
• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()
• AsyncCallback
• TimeSpan