MessageQueue.BeginReceive Methode

Referenz

Definition

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Initiiert eine asynchrone Receive-Methode, indem Message Queuing angewiesen wird, mit dem Empfangen einer Meldung zu beginnen und nach Abschluss des Vorgangs den Ereignishandler zu benachrichtigen.

Überlädt

BeginReceive()	Diese Methode initiiert einen asynchronen Empfangsvorgang ohne Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist.
BeginReceive(TimeSpan)	Diese Methode initiiert einen asynchronen Empfangsvorgang mit einem bestimmten Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist oder ein Timeout auftritt.
BeginReceive(TimeSpan, Object)	Initiiert eine asynchrone Receive-Methode mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginReceive(TimeSpan, Object, AsyncCallback)	Initiiert eine asynchrone Receive-Methode mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Initiiert einen asynchronen Receive-Vorgang, der über einen angegebenen Timeout verfügt und für den ein Cursor und ein Zustandsobjekt festgelegt sind. Das Zustandsobjekt stellt für die Lebensdauer des Vorgangs zugeordnete Informationen bereit. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.

BeginReceive()

Diese Methode initiiert einen asynchronen Empfangsvorgang ohne Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist.

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive ();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel werden asynchrone Anforderungen verkettet. Es wird davon ausgegangen, dass auf dem lokalen Computer eine Warteschlange mit dem Namen "myQueue" vorhanden ist. Die Main Funktion beginnt den asynchronen Vorgang, der von der MyReceiveCompleted Routine behandelt wird. MyReceiveCompleted verarbeitet die aktuelle Nachricht und startet 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 von BeginReceive verwendet den AsyncWaitHandle in seinem Rückgabewert. Die Main Routine wartet, bis alle asynchronen Vorgänge abgeschlossen sind, bevor sie beendet wird.

#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 der asynchronen Verarbeitung wird BeginReceive verwendet, um das ReceiveCompleted Ereignis auszulösen, wenn eine Nachricht aus der Warteschlange entfernt wurde.

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

Um zu verwenden BeginReceive, erstellen Sie einen Ereignishandler, der die Ergebnisse des asynchronen Vorgangs verarbeitet, und ordnen Sie sie Ihrem Ereignisdelegat zu. BeginReceive initiiert einen asynchronen Empfangsvorgang; wird MessageQueue über das Auslösen des ReceiveCompleted Ereignisses benachrichtigt, wenn eine Nachricht in der Warteschlange eingeht. Der MessageQueue kann dann auf die Nachricht zugreifen, indem aufgerufen EndReceive(IAsyncResult)wird.

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

Da BeginReceive 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.

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

Der IAsyncResult , der zurückgibt, BeginReceive identifiziert den asynchronen Vorgang, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie ihn in der Regel erst verwenden, wenn EndReceive(IAsyncResult) aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob auf den Abschluss aller Vorgänge oder vorgänge gewartet werden soll. In diesem Fall verwenden Sie die AsyncWaitHandle -Eigenschaft von IAsyncResult , um den abgeschlossenen Vorgang zu identifizieren.

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

Verwenden Sie den asynchronen Aufruf BeginReceive nicht mit Transaktionen. Wenn Sie einen asynchronen Transaktionsvorgang ausführen möchten, rufen Sie BeginPeekauf, und fügen Sie die Transaktion und die (synchrone) Receive Methode in den Ereignishandler ein, den Sie für den Einsehen-Vorgang erstellen. Ihr Ereignishandler kann Funktionen enthalten, wie im folgenden C#-Code gezeigt.

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

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und direktes Format	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

Gilt für:

BeginReceive(TimeSpan)

Diese Methode initiiert einen asynchronen Empfangsvorgang mit einem bestimmten Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist oder ein Timeout auftritt.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);

public IAsyncResult BeginReceive (TimeSpan timeout);

member this.BeginReceive : TimeSpan -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

Parameter

timeout: TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf eine verfügbare Meldung gewartet werden soll.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

ArgumentException

Der für den timeout-Parameter angegebene Wert ist ungültig. Möglicherweise wurde ein negativer Wert angegeben.

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird ein asynchroner Empfangsvorgang erstellt. Im Codebeispiel wird ein Ereignishandler erstellt und MyReceiveCompletedan den ReceiveCompleted Ereignishandlerdelegat angefügt. Das Codebeispiel sendet eine Nachricht an eine lokale Nachrichtenwarteschlange und ruft BeginReceive(TimeSpan)dann auf und übergibt einen Timeoutwert von zehn Sekunden. 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 der asynchronen Verarbeitung wird BeginReceive das ReceiveCompleted Ereignis ausgelöst, wenn eine Nachricht in der Warteschlange verfügbar ist oder das angegebene Zeitintervall abgelaufen ist.

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

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

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

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

Diese Überladung gibt ein 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 späterer Aufruf von EndReceive(IAsyncResult) eine Ausnahme aus.

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

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und direktes Format	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

Gilt für:

BeginReceive(TimeSpan, Object)

Initiiert eine asynchrone Receive-Methode mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.

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

timeout: TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf eine verfügbare Meldung gewartet werden soll.

stateObject: Object

Ein von der Anwendung angegebenes Zustandsobjekt, das dem asynchronen Vorgang zugeordnete Informationen enthält.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

ArgumentException

Der für den timeout-Parameter angegebene Wert ist nicht gültig.

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird ein asynchroner Empfangsvorgang erstellt. Im Codebeispiel wird ein Ereignishandler erstellt und MyReceiveCompletedan den ReceiveCompleted Ereignishandlerdelegat angefügt. Das Codebeispiel sendet eine Nachricht an eine lokale Nachrichtenwarteschlange und ruft BeginReceive(TimeSpan, Object)dann auf, und übergeben einen Timeoutwert von zehn Sekunden und eine eindeutige ganzzahlige 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 der asynchronen Verarbeitung wird BeginReceive das ReceiveCompleted Ereignis ausgelöst, wenn eine Nachricht in der Warteschlange verfügbar ist oder das angegebene Zeitintervall abgelaufen ist.

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

Verwenden Sie diese Überladung, um dem Vorgang Informationen zuzuordnen, die während der gesamten Lebensdauer des Vorgangs beibehalten werden. Der Ereignishandler kann diese Informationen erkennen, indem er sich die AsyncState -Eigenschaft der ansieht, die IAsyncResult dem Vorgang zugeordnet ist.

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

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

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 späterer Aufruf von EndReceive(IAsyncResult) eine Ausnahme aus.

Das Zustandsobjekt ordnet dem Vorgang Zustandsinformationen zu. Wenn Sie beispielsweise mehrmals 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, sich der Rückruf jedoch in einem asynchronen Szenario in einem anderen Thread befindet, wird das Zustandsobjekt gemarshallt und zusammen mit Informationen aus dem Ereignis zurückgegeben.

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

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und direktes Format	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

Gilt für:

BeginReceive(TimeSpan, Object, AsyncCallback)

Initiiert eine asynchrone Receive-Methode mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.

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

timeout: TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf eine verfügbare Meldung gewartet werden soll.

stateObject: Object

Ein von der Anwendung angegebenes Zustandsobjekt, das dem asynchronen Vorgang zugeordnete Informationen enthält.

callback: AsyncCallback

Der AsyncCallback, der die Benachrichtigung über den Abschluss des asynchronen Vorgangs erhält.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

ArgumentException

Der für den timeout-Parameter angegebene Wert ist nicht gültig.

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird ein asynchroner Empfangsvorgang erstellt. Das Codebeispiel sendet eine Nachricht an eine lokale Nachrichtenwarteschlange und ruft BeginReceive(TimeSpan, Object, AsyncCallback)dann auf, und übergibt: einen Timeoutwert von zehn Sekunden, eine eindeutige ganze Zahl, die diese bestimmte Nachricht identifiziert, und eine neue instance, AsyncCallback die 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 ist oder das angegebene Zeitintervall abgelaufen ist. Das ReceiveCompleted Ereignis wird nicht ausgelöst. Die anderen Überladungen von BeginReceive basieren auf dieser Komponente, um das Ereignis auszulösen ReceiveCompleted .

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

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

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

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

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und direktes Format	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

Gilt für:

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Initiiert einen asynchronen Receive-Vorgang, der über einen angegebenen Timeout verfügt und für den ein Cursor und ein Zustandsobjekt festgelegt sind. Das Zustandsobjekt stellt für die Lebensdauer des Vorgangs zugeordnete Informationen bereit. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.

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

timeout: TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf eine verfügbare Meldung gewartet werden soll.

cursor: Cursor

Ein Cursor, der eine bestimmte Position in der Meldungswarteschlange beibehält.

state: Object

Ein von der Anwendung angegebenes Zustandsobjekt, das dem asynchronen Vorgang zugeordnete Informationen enthält.

callback: AsyncCallback

Der AsyncCallback, der die Benachrichtigung über den Abschluss des asynchronen Vorgangs erhält.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

ArgumentNullException

Der cursor-Parameter ist null.

ArgumentException

Der für den timeout-Parameter angegebene Wert ist nicht gültig.

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Hinweise

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

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

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

Der IAsyncResult , der zurückgibt, BeginReceive identifiziert den asynchronen Vorgang, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie ihn in der Regel erst verwenden, wenn EndReceive(IAsyncResult) aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob auf den Abschluss aller Vorgänge oder vorgänge gewartet werden soll. Verwenden Sie in diesem Fall die AsyncWaitHandle -Eigenschaft von IAsyncResult , um den abgeschlossenen Vorgang zu identifizieren.

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

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und direktes Format	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

Gilt für:

Threadsicherheit

Die -Methode ist nicht threadsicher.

MessageQueue.BeginReceive Methode

Definition

Überlädt

BeginReceive()

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

BeginReceive(TimeSpan)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

BeginReceive(TimeSpan, Object)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

BeginReceive(TimeSpan, Object, AsyncCallback)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Threadsicherheit

Feedback

Zusätzliche Ressourcen