MessageQueue.BeginReceive Methode

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Retouren

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld worden asynchrone aanvragen gekoppeld. Hierbij wordt ervan uitgegaan dat er een wachtrij is op de lokale computer met de naam 'myQueue'. De Main functie begint de asynchrone bewerking die wordt verwerkt door de MyReceiveCompleted routine. MyReceiveCompleted verwerkt het huidige bericht en begint een nieuwe asynchrone ontvangstbewerking.

#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

In het volgende codevoorbeeld worden asynchrone aanvragen in de wachtrij geplaatst. De aanroep om de AsyncWaitHandle retourwaarde te BeginReceive gebruiken. De Main routine wacht totdat alle asynchrone bewerkingen zijn voltooid voordat ze worden afgesloten.

#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

Opmerkingen

Bij asynchrone verwerking gebruikt BeginReceive u om de ReceiveCompleted gebeurtenis te genereren wanneer een bericht uit de wachtrij is verwijderd.

ReceiveCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

Als u dit wilt gebruiken BeginReceive, maakt u een gebeurtenis-handler die de resultaten van de asynchrone bewerking verwerkt en koppelt u deze aan uw gebeurtenisdelegent. BeginReceive initieert een asynchrone ontvangstbewerking; de MessageQueue melding wordt ontvangen door middel van het genereren van de ReceiveCompleted gebeurtenis wanneer een bericht in de wachtrij binnenkomt. De MessageQueue kan het bericht vervolgens openen door te bellen EndReceive(IAsyncResult).

De BeginReceive methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Omdat BeginReceive dit asynchroon is, kunt u het aanroepen om een bericht uit de wachtrij te ontvangen zonder dat de huidige thread van de uitvoering wordt geblokkeerd. Als u een bericht synchroon wilt ontvangen, gebruikt u de Receive methode.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

De IAsyncResult retourneert BeginReceive de asynchrone bewerking die door de methode is gestart. U kunt dit IAsyncResult gedurende de hele levensduur van de bewerking gebruiken, hoewel u deze over het algemeen niet gebruikt totdat EndReceive(IAsyncResult) deze wordt aangeroepen. Als u echter verschillende asynchrone bewerkingen start, kunt u de IAsyncResult waarden in een matrix plaatsen en opgeven of u wilt wachten tot alle bewerkingen of bewerkingen zijn voltooid. In dit geval gebruikt u de AsyncWaitHandle eigenschap van de IAsyncResult functie om de voltooide bewerking te identificeren.

Als CanRead dat het geval is false, wordt de voltooiingsgebeurtenis gegenereerd, maar er wordt een uitzondering gegenereerd bij het aanroepen EndReceive(IAsyncResult).

Gebruik de asynchrone aanroep BeginReceive niet met transacties. Als u een transactionele asynchrone bewerking wilt uitvoeren, roept BeginPeeku de transactie aan en plaatst u de transactie en de (synchrone) Receive methode in de gebeurtenis-handler die u maakt voor de peek-bewerking. Uw gebeurtenis-handler kan functionaliteit bevatten, zoals wordt weergegeven in de volgende C#-code.

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

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

• 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

Parameters

Retouren

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld wordt een asynchrone ontvangstbewerking gemaakt. In het codevoorbeeld wordt een gebeurtenis-handler MyReceiveCompletedgemaakt en gekoppeld aan de gemachtigde van de ReceiveCompleted gebeurtenis-handler. Het codevoorbeeld verzendt een bericht naar een lokale berichtenwachtrij en roept BeginReceive(TimeSpan)vervolgens een time-outwaarde van tien seconden door. Wanneer een ReceiveCompleted gebeurtenis wordt gegenereerd, ontvangt de gebeurtenis-handler het bericht en schrijft de berichttekst naar het scherm.

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

Opmerkingen

Bij asynchrone verwerking gebruikt BeginReceive u om de ReceiveCompleted gebeurtenis te genereren wanneer een bericht beschikbaar komt in de wachtrij of wanneer het opgegeven tijdsinterval is verlopen.

ReceiveCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

Als u dit wilt gebruiken BeginReceive, maakt u een gebeurtenis-handler die de resultaten van de asynchrone bewerking verwerkt en koppelt u deze aan uw gebeurtenisdelegent. BeginReceive initieert een asynchrone ontvangstbewerking; de MessageQueue melding wordt ontvangen door middel van het genereren van de ReceiveCompleted gebeurtenis wanneer een bericht in de wachtrij binnenkomt. De MessageQueue kan het bericht vervolgens openen door het resultaat aan te roepen EndReceive(IAsyncResult) of op te halen met behulp van de ReceiveCompletedEventArgs.

De BeginReceive methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Omdat BeginReceive dit asynchroon is, kunt u het aanroepen om een bericht uit de wachtrij te ontvangen zonder dat de huidige thread van de uitvoering wordt geblokkeerd. Als u een bericht synchroon wilt ontvangen, gebruikt u de Receive methode.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

Als CanRead dat het geval is false, wordt de voltooiingsgebeurtenis gegenereerd, maar er wordt een uitzondering gegenereerd bij het aanroepen EndReceive(IAsyncResult).

De IAsyncResult retourneert BeginReceive de asynchrone bewerking die door de methode is gestart. U kunt dit IAsyncResult gedurende de hele levensduur van de bewerking gebruiken, hoewel u deze over het algemeen niet gebruikt totdat EndReceive(IAsyncResult) deze wordt aangeroepen. Als u echter verschillende asynchrone bewerkingen start, kunt u de IAsyncResult waarden in een matrix plaatsen en opgeven of u wilt wachten tot alle bewerkingen of bewerkingen zijn voltooid. In dit geval gebruikt u de AsyncWaitHandle eigenschap van de IAsyncResult functie om de voltooide bewerking te identificeren.

Deze overbelasting geeft een time-out op. Als het interval dat door de timeout parameter is opgegeven, verloopt, wordt de ReceiveCompleted gebeurtenis gegenereerd door dit onderdeel. Omdat er geen bericht bestaat, genereert een volgende aanroep een EndReceive(IAsyncResult) uitzondering.

Gebruik de asynchrone aanroep BeginReceive niet met transacties. Als u een transactionele asynchrone bewerking wilt uitvoeren, roept BeginPeeku de transactie aan en plaatst u de transactie en de (synchrone) Receive methode in de gebeurtenis-handler die u maakt voor de peek-bewerking. Uw gebeurtenis-handler kan functionaliteit bevatten, zoals wordt weergegeven in de volgende C#-code.

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

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

• 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

Parameters

Retouren

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld wordt een asynchrone ontvangstbewerking gemaakt. In het codevoorbeeld wordt een gebeurtenis-handler MyReceiveCompletedgemaakt en gekoppeld aan de gemachtigde van de ReceiveCompleted gebeurtenis-handler. Het codevoorbeeld verzendt een bericht naar een lokale berichtenwachtrij en roept BeginReceive(TimeSpan, Object)vervolgens een time-outwaarde van tien seconden door en een uniek geheel getal waarmee dat specifieke bericht wordt geïdentificeerd. Wanneer een ReceiveCompleted gebeurtenis wordt gegenereerd, ontvangt de gebeurtenis-handler het bericht en schrijft de berichttekst en de id van het gehele bericht naar het scherm.

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

Opmerkingen

Bij asynchrone verwerking gebruikt BeginReceive u om de ReceiveCompleted gebeurtenis te genereren wanneer een bericht beschikbaar komt in de wachtrij of wanneer het opgegeven tijdsinterval is verlopen.

ReceiveCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

Gebruik deze overbelasting om informatie te koppelen aan de bewerking die gedurende de levensduur van de bewerking behouden blijft. De gebeurtenis-handler kan deze informatie detecteren door te kijken naar de AsyncState eigenschap van de IAsyncResult eigenschap die aan de bewerking is gekoppeld.

Als u dit wilt gebruiken BeginReceive, maakt u een gebeurtenis-handler die de resultaten van de asynchrone bewerking verwerkt en koppelt u deze aan uw gebeurtenisdelegent. BeginReceive initieert een asynchrone ontvangstbewerking; de MessageQueue melding wordt ontvangen door middel van het genereren van de ReceiveCompleted gebeurtenis wanneer een bericht in de wachtrij binnenkomt. De MessageQueue kan het bericht vervolgens openen door het resultaat aan te roepen EndReceive(IAsyncResult) of op te halen met behulp van de ReceiveCompletedEventArgs.

De BeginReceive methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Omdat BeginReceive dit asynchroon is, kunt u het aanroepen om een bericht uit de wachtrij te ontvangen zonder dat de huidige thread van de uitvoering wordt geblokkeerd. Als u een bericht synchroon wilt ontvangen, gebruikt u de Receive methode.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

De IAsyncResult retourneert BeginReceive de asynchrone bewerking die door de methode is gestart. U kunt dit IAsyncResult gedurende de hele levensduur van de bewerking gebruiken, hoewel u deze over het algemeen niet gebruikt totdat EndReceive(IAsyncResult) deze wordt aangeroepen. Als u echter verschillende asynchrone bewerkingen start, kunt u de IAsyncResult waarden in een matrix plaatsen en opgeven of u wilt wachten tot alle bewerkingen of bewerkingen zijn voltooid. In dit geval gebruikt u de AsyncWaitHandle eigenschap van de IAsyncResult functie om de voltooide bewerking te identificeren.

Deze overbelasting geeft een time-out en een statusobject op. Als het interval dat door de timeout parameter is opgegeven, verloopt, wordt de ReceiveCompleted gebeurtenis gegenereerd door dit onderdeel. Omdat er geen bericht bestaat, genereert een volgende aanroep een EndReceive(IAsyncResult) uitzondering.

Het statusobject koppelt statusgegevens aan de bewerking. Als u bijvoorbeeld meerdere keren aanroept BeginReceive om meerdere bewerkingen te starten, kunt u elke bewerking identificeren via een afzonderlijk statusobject dat u definieert.

U kunt het statusobject ook gebruiken om informatie door te geven over procesthreads. Als een thread wordt gestart, maar de callback zich op een andere thread in een asynchroon scenario bevindt, wordt het statusobject marshaled en wordt het doorgegeven samen met informatie van de gebeurtenis.

Gebruik de asynchrone aanroep BeginReceive niet met transacties. Als u een transactionele asynchrone bewerking wilt uitvoeren, roept BeginPeeku de transactie aan en plaatst u de transactie en de (synchrone) Receive methode in de gebeurtenis-handler die u maakt voor de peek-bewerking. Uw gebeurtenis-handler kan functionaliteit bevatten, zoals wordt weergegeven in de volgende C#-code.

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

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

• 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

Parameters

Retouren

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld wordt een asynchrone ontvangstbewerking gemaakt. In het codevoorbeeld wordt een bericht verzonden naar een lokale berichtenwachtrij en vervolgens wordt aangeroepenBeginReceive(TimeSpan, Object, AsyncCallback), waarbij het volgende wordt doorgegeven: een time-outwaarde van tien seconden; een uniek geheel getal dat dat bericht identificeert; en een nieuw exemplaar van AsyncCallback dat de gebeurtenis-handler identificeert. MyReceiveCompleted Wanneer een ReceiveCompleted gebeurtenis wordt gegenereerd, ontvangt de gebeurtenis-handler het bericht en schrijft de berichttekst en de id van het gehele bericht naar het scherm.

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

Opmerkingen

Wanneer u deze overbelasting gebruikt, wordt de callback die is opgegeven in de callbackparameter rechtstreeks aangeroepen wanneer een bericht beschikbaar is in de wachtrij of wanneer het opgegeven tijdsinterval is verlopen; de ReceiveCompleted gebeurtenis wordt niet gegenereerd. De andere overbelastingen zijn afhankelijk van BeginReceive dit onderdeel om de ReceiveCompleted gebeurtenis te verhogen.

ReceiveCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

Als u dit wilt gebruiken BeginReceive, maakt u een gebeurtenis-handler die de resultaten van de asynchrone bewerking verwerkt en koppelt u deze aan uw gebeurtenisdelegent. BeginReceive initieert een asynchrone ontvangstbewerking; de MessageQueue melding wordt ontvangen door middel van het genereren van de ReceiveCompleted gebeurtenis wanneer een bericht in de wachtrij binnenkomt. De MessageQueue kan het bericht vervolgens openen door het resultaat aan te roepen EndReceive(IAsyncResult) of op te halen met behulp van de ReceiveCompletedEventArgs.

De BeginReceive methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Omdat BeginReceive dit asynchroon is, kunt u het aanroepen om een bericht uit de wachtrij te ontvangen zonder dat de huidige thread van de uitvoering wordt geblokkeerd. Als u een bericht synchroon wilt ontvangen, gebruikt u de Receive methode.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

De IAsyncResult retourneert BeginReceive de asynchrone bewerking die door de methode is gestart. U kunt dit IAsyncResult gedurende de hele levensduur van de bewerking gebruiken, hoewel u deze over het algemeen niet gebruikt totdat EndReceive(IAsyncResult) deze wordt aangeroepen. Als u echter verschillende asynchrone bewerkingen start, kunt u de IAsyncResult waarden in een matrix plaatsen en opgeven of u wilt wachten tot alle bewerkingen of bewerkingen zijn voltooid. In dit geval gebruikt u de AsyncWaitHandle eigenschap van de IAsyncResult functie om de voltooide bewerking te identificeren.

Het statusobject koppelt statusgegevens aan de bewerking. Als u bijvoorbeeld meerdere keren aanroept BeginReceive om meerdere bewerkingen te starten, kunt u elke bewerking identificeren via een afzonderlijk statusobject dat u definieert.

U kunt het statusobject ook gebruiken om informatie door te geven over procesthreads. Als een thread wordt gestart, maar de callback zich op een andere thread in een asynchroon scenario bevindt, wordt het statusobject marshaled en wordt het doorgegeven samen met informatie van de gebeurtenis.

Gebruik de asynchrone aanroep BeginReceive niet met transacties. Als u een transactionele asynchrone bewerking wilt uitvoeren, roept BeginPeeku de transactie aan en plaatst u de transactie en de (synchrone) Receive methode in de gebeurtenis-handler die u maakt voor de peek-bewerking. Uw gebeurtenis-handler kan functionaliteit bevatten, zoals wordt weergegeven in de volgende C#-code.

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

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

• 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

Parameters

Retouren

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

Opmerkingen

Wanneer u deze overbelasting gebruikt, wordt de callback die is opgegeven in de callbackparameter rechtstreeks aangeroepen wanneer een bericht beschikbaar is in de wachtrij of wanneer het opgegeven tijdsinterval is verlopen; de ReceiveCompleted gebeurtenis wordt niet gegenereerd. De andere overbelastingen zijn afhankelijk van BeginReceive dit onderdeel om de ReceiveCompleted gebeurtenis te verhogen.

ReceiveCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

Als u dit wilt gebruiken BeginReceive, maakt u een gebeurtenis-handler die de resultaten van de asynchrone bewerking verwerkt en koppelt u deze aan uw gebeurtenisdelegent. BeginReceive initieert een asynchrone ontvangstbewerking; de MessageQueue melding wordt ontvangen door middel van het genereren van de ReceiveCompleted gebeurtenis wanneer een bericht in de wachtrij binnenkomt. De MessageQueue kan het bericht vervolgens openen door het resultaat aan te roepen EndReceive(IAsyncResult) of op te halen met behulp van de ReceiveCompletedEventArgs.

De BeginReceive methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Omdat BeginReceive dit asynchroon is, kunt u het aanroepen om een bericht uit de wachtrij te ontvangen zonder dat de huidige thread van de uitvoering wordt geblokkeerd. Als u een bericht synchroon wilt ontvangen, gebruikt u de Receive methode.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

De IAsyncResult retourneert BeginReceive de asynchrone bewerking die door de methode is gestart. U kunt dit IAsyncResult gedurende de hele levensduur van de bewerking gebruiken, hoewel u deze over het algemeen niet gebruikt totdat EndReceive(IAsyncResult) deze wordt aangeroepen. Als u echter verschillende asynchrone bewerkingen start, kunt u de IAsyncResult waarden in een matrix plaatsen en opgeven of u wilt wachten tot alle bewerkingen of bewerkingen zijn voltooid. In dit geval gebruikt u de AsyncWaitHandle eigenschap van de IAsyncResult functie om de voltooide bewerking te identificeren.

Het statusobject koppelt statusgegevens aan de bewerking. Als u bijvoorbeeld meerdere keren aanroept BeginReceive om meerdere bewerkingen te starten, kunt u elke bewerking identificeren via een afzonderlijk statusobject dat u definieert.

U kunt het statusobject ook gebruiken om informatie door te geven over procesthreads. Als een thread wordt gestart, maar de callback zich op een andere thread in een asynchroon scenario bevindt, wordt het statusobject marshaled en wordt het doorgegeven samen met informatie van de gebeurtenis.

Gebruik de asynchrone aanroep BeginReceive niet met transacties. Als u een transactionele asynchrone bewerking wilt uitvoeren, roept BeginPeeku de transactie aan en plaatst u de transactie en de (synchrone) Receive methode in de gebeurtenis-handler die u maakt voor de peek-bewerking. Uw gebeurtenis-handler kan functionaliteit bevatten, zoals wordt weergegeven in de volgende C#-code.

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

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

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