MessageQueue.BeginReceive Metod

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Exempel

I följande kodexempel kedjas asynkrona begäranden. Det förutsätter att det finns en kö på den lokala datorn med namnet "myQueue". Funktionen Main påbörjar den asynkrona åtgärd som hanteras av rutinen MyReceiveCompleted . MyReceiveCompleted bearbetar det aktuella meddelandet och påbörjar en ny asynkron mottagningsåtgärd.

#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

Följande kodexempel köar asynkrona begäranden. Anropet till BeginReceive använder AsyncWaitHandle i sitt returvärde. Rutinen Main väntar på att alla asynkrona åtgärder ska slutföras innan de avslutas.

#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

Kommentarer

Vid asynkron bearbetning använder BeginReceive du för att skapa ReceiveCompleted händelsen när ett meddelande har tagits bort från kön.

ReceiveCompleted utlöses också om det redan finns ett meddelande i kön.

Om du vill använda BeginReceiveskapar du en händelsehanterare som bearbetar resultatet av den asynkrona åtgärden och associerar den med händelsedelegaten. BeginReceive initierar en asynkron mottagningsåtgärd. MessageQueue meddelas, genom att händelsen höjs ReceiveCompleted , när ett meddelande tas emot i kön. MessageQueue Kan sedan komma åt meddelandet genom att anropa EndReceive(IAsyncResult).

Metoden BeginReceive returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginReceive det är asynkront kan du anropa det för att ta emot ett meddelande från kön utan att blockera den aktuella körningstråden. Om du vill ta emot ett meddelande synkront använder du Receive metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

IAsyncResult Som BeginReceive returnerar identifierar den asynkrona åtgärd som metoden startade. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndReceive(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder AsyncWaitHandle du egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Om CanRead är falseutlöses slutförandehändelsen, men ett undantag utlöses när du anropar EndReceive(IAsyncResult).

Använd inte det asynkrona anropet BeginReceive med transaktioner. Om du vill utföra en transaktionell asynkron åtgärd anropar BeginPeekdu och placerar transaktionen och metoden (synkron) Receive i händelsehanteraren som du skapar för granskningsåtgärden. Händelsehanteraren kan innehålla funktioner som visas i följande C#-kod.

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

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• 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

Parametrar

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Exempel

I följande kodexempel skapas en asynkron mottagningsåtgärd. Kodexemplet skapar en händelsehanterare, MyReceiveCompleted, och kopplar den till händelsehanterardelegaten ReceiveCompleted . Kodexemplet skickar ett meddelande till en lokal meddelandekö och anropar BeginReceive(TimeSpan)sedan och skickar ett timeout-värde på tio sekunder. När en ReceiveCompleted händelse utlöses tar händelsehanteraren emot meddelandet och skriver meddelandetexten till skärmen.

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

Kommentarer

Vid asynkron bearbetning använder BeginReceive du för att skapa ReceiveCompleted händelsen när ett meddelande blir tillgängligt i kön eller när det angivna tidsintervallet har upphört att gälla.

ReceiveCompleted utlöses också om det redan finns ett meddelande i kön.

Om du vill använda BeginReceiveskapar du en händelsehanterare som bearbetar resultatet av den asynkrona åtgärden och associerar den med händelsedelegaten. BeginReceive initierar en asynkron mottagningsåtgärd. MessageQueue meddelas, genom att händelsen höjs ReceiveCompleted , när ett meddelande tas emot i kön. MessageQueue Kan sedan komma åt meddelandet genom att anropa EndReceive(IAsyncResult) eller hämta resultatet med hjälp av ReceiveCompletedEventArgs.

Metoden BeginReceive returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginReceive det är asynkront kan du anropa det för att ta emot ett meddelande från kön utan att blockera den aktuella körningstråden. Om du vill ta emot ett meddelande synkront använder du Receive metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

Om CanRead är falseutlöses slutförandehändelsen, men ett undantag utlöses när du anropar EndReceive(IAsyncResult).

IAsyncResult Som BeginReceive returnerar identifierar den asynkrona åtgärd som metoden startade. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndReceive(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder AsyncWaitHandle du egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Den här överlagringen anger en tidsgräns. Om intervallet som anges av parametern timeout upphör att gälla genererar den här komponenten ReceiveCompleted händelsen. Eftersom det inte finns något meddelande utlöser ett efterföljande anrop till EndReceive(IAsyncResult) ett undantag.

Använd inte det asynkrona anropet BeginReceive med transaktioner. Om du vill utföra en transaktionell asynkron åtgärd anropar BeginPeekdu och placerar transaktionen och metoden (synkron) Receive i händelsehanteraren som du skapar för granskningsåtgärden. Händelsehanteraren kan innehålla funktioner som visas i följande C#-kod.

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

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• 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

Parametrar

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Exempel

I följande kodexempel skapas en asynkron mottagningsåtgärd. Kodexemplet skapar en händelsehanterare, MyReceiveCompleted, och kopplar den till händelsehanterardelegaten ReceiveCompleted . Kodexemplet skickar ett meddelande till en lokal meddelandekö och anropar BeginReceive(TimeSpan, Object)sedan och skickar in ett timeout-värde på tio sekunder och ett unikt heltal som identifierar det specifika meddelandet. När en ReceiveCompleted händelse utlöses tar händelsehanteraren emot meddelandet och skriver meddelandetexten och heltalsmeddelandeidentifieraren till skärmen.

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

Kommentarer

Vid asynkron bearbetning använder BeginReceive du för att skapa ReceiveCompleted händelsen när ett meddelande blir tillgängligt i kön eller när det angivna tidsintervallet har upphört att gälla.

ReceiveCompleted utlöses också om det redan finns ett meddelande i kön.

Använd den här överlagringen för att associera information med den åtgärd som ska bevaras under hela åtgärdens livslängd. Händelsehanteraren kan identifiera den här informationen genom att titta på AsyncState egenskapen för den IAsyncResult som är associerad med åtgärden.

Om du vill använda BeginReceiveskapar du en händelsehanterare som bearbetar resultatet av den asynkrona åtgärden och associerar den med händelsedelegaten. BeginReceive initierar en asynkron mottagningsåtgärd. MessageQueue meddelas, genom att händelsen höjs ReceiveCompleted , när ett meddelande tas emot i kön. MessageQueue Kan sedan komma åt meddelandet genom att anropa EndReceive(IAsyncResult) eller hämta resultatet med hjälp av ReceiveCompletedEventArgs.

Metoden BeginReceive returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginReceive det är asynkront kan du anropa det för att ta emot ett meddelande från kön utan att blockera den aktuella körningstråden. Om du vill ta emot ett meddelande synkront använder du Receive metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

IAsyncResult Som BeginReceive returnerar identifierar den asynkrona åtgärd som metoden startade. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndReceive(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder AsyncWaitHandle du egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Den här överlagringen anger en timeout och ett tillståndsobjekt. Om intervallet som anges av parametern timeout upphör att gälla genererar den här komponenten ReceiveCompleted händelsen. Eftersom det inte finns något meddelande utlöser ett efterföljande anrop till EndReceive(IAsyncResult) ett undantag.

Tillståndsobjektet associerar tillståndsinformation med åtgärden. Om du till exempel anropar BeginReceive flera gånger för att initiera flera åtgärder kan du identifiera varje åtgärd via ett separat tillståndsobjekt som du definierar.

Du kan också använda tillståndsobjektet för att skicka information mellan processtrådar. Om en tråd startas men återanropet finns på en annan tråd i ett asynkront scenario, konverteras tillståndsobjektet och skickas tillbaka tillsammans med information från händelsen.

Använd inte det asynkrona anropet BeginReceive med transaktioner. Om du vill utföra en transaktionell asynkron åtgärd anropar BeginPeekdu och placerar transaktionen och metoden (synkron) Receive i händelsehanteraren som du skapar för granskningsåtgärden. Händelsehanteraren kan innehålla funktioner som visas i följande C#-kod.

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

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• 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

Parametrar

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Exempel

I följande kodexempel skapas en asynkron mottagningsåtgärd. Kodexemplet skickar ett meddelande till en lokal meddelandekö och anropar BeginReceive(TimeSpan, Object, AsyncCallback), skickar in: ett timeout-värde på tio sekunder, ett unikt heltal som identifierar det specifika meddelandet och en ny instans av AsyncCallback som identifierar händelsehanteraren. MyReceiveCompleted När en ReceiveCompleted händelse utlöses tar händelsehanteraren emot meddelandet och skriver meddelandetexten och heltalsmeddelandeidentifieraren till skärmen.

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

Kommentarer

När du använder den här överbelastningen anropas återanropet som anges i motringningsparametern direkt när ett meddelande blir tillgängligt i kön eller när det angivna tidsintervallet har upphört att gälla. händelsen ReceiveCompleted har inte aktiverats. De andra överlagringarna av BeginReceive förlitar sig på den här komponenten ReceiveCompleted för att generera händelsen.

ReceiveCompleted utlöses också om det redan finns ett meddelande i kön.

Om du vill använda BeginReceiveskapar du en händelsehanterare som bearbetar resultatet av den asynkrona åtgärden och associerar den med händelsedelegaten. BeginReceive initierar en asynkron mottagningsåtgärd. MessageQueue meddelas, genom att händelsen höjs ReceiveCompleted , när ett meddelande tas emot i kön. MessageQueue Kan sedan komma åt meddelandet genom att anropa EndReceive(IAsyncResult) eller hämta resultatet med hjälp av ReceiveCompletedEventArgs.

Metoden BeginReceive returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginReceive det är asynkront kan du anropa det för att ta emot ett meddelande från kön utan att blockera den aktuella körningstråden. Om du vill ta emot ett meddelande synkront använder du Receive metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

IAsyncResult Som BeginReceive returnerar identifierar den asynkrona åtgärd som metoden startade. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndReceive(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder AsyncWaitHandle du egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Tillståndsobjektet associerar tillståndsinformation med åtgärden. Om du till exempel anropar BeginReceive flera gånger för att initiera flera åtgärder kan du identifiera varje åtgärd via ett separat tillståndsobjekt som du definierar.

Du kan också använda tillståndsobjektet för att skicka information mellan processtrådar. Om en tråd startas men återanropet finns på en annan tråd i ett asynkront scenario, konverteras tillståndsobjektet och skickas tillbaka tillsammans med information från händelsen.

Använd inte det asynkrona anropet BeginReceive med transaktioner. Om du vill utföra en transaktionell asynkron åtgärd anropar BeginPeekdu och placerar transaktionen och metoden (synkron) Receive i händelsehanteraren som du skapar för granskningsåtgärden. Händelsehanteraren kan innehålla funktioner som visas i följande C#-kod.

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

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• 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

Parametrar

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Kommentarer

När du använder den här överbelastningen anropas återanropet som anges i motringningsparametern direkt när ett meddelande blir tillgängligt i kön eller när det angivna tidsintervallet har upphört att gälla. händelsen ReceiveCompleted har inte aktiverats. De andra överlagringarna av BeginReceive förlitar sig på den här komponenten ReceiveCompleted för att generera händelsen.

ReceiveCompleted utlöses också om det redan finns ett meddelande i kön.

Om du vill använda BeginReceiveskapar du en händelsehanterare som bearbetar resultatet av den asynkrona åtgärden och associerar den med händelsedelegaten. BeginReceive initierar en asynkron mottagningsåtgärd. MessageQueue meddelas, genom att händelsen höjs ReceiveCompleted , när ett meddelande tas emot i kön. MessageQueue Kan sedan komma åt meddelandet genom att anropa EndReceive(IAsyncResult) eller hämta resultatet med hjälp av ReceiveCompletedEventArgs.

Metoden BeginReceive returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginReceive det är asynkront kan du anropa det för att ta emot ett meddelande från kön utan att blockera den aktuella körningstråden. Om du vill ta emot ett meddelande synkront använder du Receive metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

IAsyncResult Som BeginReceive returnerar identifierar den asynkrona åtgärd som metoden startade. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndReceive(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder du AsyncWaitHandle egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Tillståndsobjektet associerar tillståndsinformation med åtgärden. Om du till exempel anropar BeginReceive flera gånger för att initiera flera åtgärder kan du identifiera varje åtgärd via ett separat tillståndsobjekt som du definierar.

Du kan också använda tillståndsobjektet för att skicka information mellan processtrådar. Om en tråd startas men återanropet finns på en annan tråd i ett asynkront scenario, konverteras tillståndsobjektet och skickas tillbaka tillsammans med information från händelsen.

Använd inte det asynkrona anropet BeginReceive med transaktioner. Om du vill utföra en transaktionell asynkron åtgärd anropar BeginPeekdu och placerar transaktionen och metoden (synkron) Receive i händelsehanteraren som du skapar för granskningsåtgärden. Händelsehanteraren kan innehålla funktioner som visas i följande C#-kod.

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

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

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