MessageQueue.BeginReceive Metoda

Definicja

Inicjuje asynchroniczną operację odbierania, informując usługę kolejkowania komunikatów o rozpoczęciu odbierania komunikatu i powiadamiania programu obsługi zdarzeń po zakończeniu.Initiates an asynchronous receive operation by telling Message Queuing to begin receiving a message and notify the event handler when finished.

Przeciążenia

BeginReceive()

Inicjuje asynchroniczną operację odbierania, która nie ma limitu czasu. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginReceive(TimeSpan)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object)

Inicjuje asynchroniczne operacje odbierania z określonym limitem czasu i określonym obiektem stanu, który zawiera skojarzone informacje w okresie istnienia operacji.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object, AsyncCallback)

Inicjuje asynchroniczne operacje odbierania z określonym limitem czasu i określonym obiektem stanu, który zawiera skojarzone informacje w okresie istnienia operacji.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. To Przeciążenie odbiera powiadomienie przy użyciu wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji.This overload receives notification, through a callback, of the identity of the event handler for the operation. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu i używa określonego kursora i określonego obiektu stanu.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. Obiekt State zawiera powiązane informacje w okresie istnienia operacji.The state object provides associated information throughout the lifetime of the operation. To Przeciążenie odbiera powiadomienie przy użyciu wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji.This overload receives notification, through a callback, of the identity of the event handler for the operation. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive()

Inicjuje asynchroniczną operację odbierania, która nie ma limitu czasu. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

public:
 IAsyncResult ^ BeginReceive();
public IAsyncResult BeginReceive ();
member this.BeginReceive : unit -> IAsyncResult
Public Function BeginReceive () As IAsyncResult

Zwraca

IAsyncResult

IAsyncResult, który identyfikuje ogłoszone żądanie asynchroniczne.The IAsyncResult that identifies the posted asynchronous request.

Wyjątki

Wystąpił błąd podczas uzyskiwania dostępu do metody usługi kolejkowania komunikatów.An error occurred when accessing a Message Queuing method.

Przykłady

Poniższy przykład kodu łańcuchuje asynchroniczne żądania.The following code example chains asynchronous requests. Przyjęto założenie, że na komputerze lokalnym istnieje kolejka o nazwie "Moja kolejka".It assumes there is a queue on the local computer called "myQueue". Funkcja Main rozpoczyna operację asynchroniczną, która jest obsługiwana przez procedurę MyReceiveCompleted.The Main function begins the asynchronous operation that is handled by the MyReceiveCompleted routine. MyReceiveCompleted przetwarza bieżący komunikat i rozpoczyna nową asynchroniczną operację odbierania.MyReceiveCompleted processes the current message and begins a new asynchronous receive operation.

#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

Poniższy przykład kodu kolejkuje asynchroniczne żądania.The following code example queues asynchronous requests. Wywołanie BeginReceive używa AsyncWaitHandle w zwracanej wartości.The call to BeginReceive uses the AsyncWaitHandle in its return value. Procedura Main czeka na zakończenie wszystkich operacji asynchronicznych przed wyjściem.The Main routine waits for all asynchronous operations to be completed before exiting.

#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

Uwagi

W przypadku przetwarzania asynchronicznego należy użyć BeginReceive, aby zgłosić zdarzenie ReceiveCompleted, gdy komunikat został usunięty z kolejki.In asynchronous processing, you use BeginReceive to raise the ReceiveCompleted event when a message has been removed from the queue.

ReceiveCompleted jest również zgłaszane, jeśli komunikat już istnieje w kolejce.ReceiveCompleted is also raised if a message already exists in the queue.

Aby użyć BeginReceive, należy utworzyć procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i kojarzy ją z delegatem zdarzenia.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceive inicjuje asynchroniczną operację odbierania; MessageQueue zostaje powiadomiony przez podnoszenie poziomu zdarzenia ReceiveCompleted, gdy wiadomość dociera do kolejki.BeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. MessageQueue może następnie uzyskać dostęp do komunikatu, wywołując EndReceive(IAsyncResult).The MessageQueue can then access the message by calling EndReceive(IAsyncResult).

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie zakończona do momentu wywołania programu obsługi zdarzeń.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Ponieważ BeginReceive jest asynchroniczny, można wywołać go, aby odebrać komunikat z kolejki bez blokowania bieżącego wątku wykonywania.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Aby synchronicznie odebrać komunikat, użyj metody Receive.To synchronously receive a message, use the Receive method.

Po zakończeniu operacji asynchronicznej można wywołać BeginPeek lub BeginReceive ponownie w programie obsługi zdarzeń, aby nadal otrzymywać powiadomienia.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

IAsyncResult, które BeginReceive zwraca, identyfikuje operację asynchroniczną, która została uruchomiona.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. Tej IAsyncResult można użyć w okresie istnienia operacji, chociaż zwykle nie jest używana do momentu wywołania metody EndReceive(IAsyncResult).You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Jeśli jednak uruchamiasz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy czekać na wszystkie operacje, czy dowolna operacja zostanie ukończona.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. W takim przypadku należy użyć właściwości AsyncWaitHandle IAsyncResult, aby zidentyfikować ukończoną operację.In this case, you use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

Jeśli CanRead jest false, zostanie zgłoszone zdarzenie ukończenia, ale podczas wywoływania EndReceive(IAsyncResult)wystąpi wyjątek.If CanRead is false, the completion event is raised, but an exception will be thrown when calling EndReceive(IAsyncResult).

Nie używaj wywołań asynchronicznych BeginReceive z transakcjami.Do not use the asynchronous call BeginReceive with transactions. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeeki umieść transakcję i metodę Receive (synchroniczna) w ramach procedury obsługi zdarzeń utworzonej dla operacji wglądu.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Program obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym C# kodzie.Your event handler might contain functionality as shown in the following C# code.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.The following table shows whether this method is available in various Workgroup modes.

Tryb grupy roboczejWorkgroup mode DostępneAvailable
Komputer lokalnyLocal computer TakYes
Nazwa komputera lokalnego i bezpośredniegoLocal computer and direct format name TakYes
Komputer zdalnyRemote computer NieNo
Nazwa komputera zdalnego i bezpośredniegoRemote computer and direct format name TakYes

Zobacz też

BeginReceive(TimeSpan)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);
public IAsyncResult BeginReceive (TimeSpan timeout);
member this.BeginReceive : TimeSpan -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

Parametry

timeout
TimeSpan

TimeSpan, który wskazuje interwał czasu oczekiwania na udostępnienie komunikatu.A TimeSpan that indicates the interval of time to wait for a message to become available.

Zwraca

IAsyncResult

IAsyncResult, który identyfikuje ogłoszone żądanie asynchroniczne.The IAsyncResult that identifies the posted asynchronous request.

Wyjątki

Wartość określona dla parametru timeout jest nieprawidłowa, prawdopodobnie dlatego, że reprezentuje liczbę ujemną.The value specified for the timeout parameter is not valid, possibly because it represents a negative number.

Wystąpił błąd podczas uzyskiwania dostępu do metody usługi kolejkowania komunikatów.An error occurred when accessing a Message Queuing method.

Przykłady

Poniższy przykład kodu tworzy asynchroniczną operację odbierania.The following code example creates an asynchronous receive operation. Przykładowy kod tworzy program obsługi zdarzeń, MyReceiveCompletedi dołącza go do delegata obsługi zdarzeń ReceiveCompleted.The code example creates an event handler, MyReceiveCompleted, and attaches it to the ReceiveCompleted event handler delegate. Przykładowy kod wysyła komunikat do lokalnej kolejki komunikatów, a następnie wywołuje BeginReceive(TimeSpan), przekazując wartość w przekroczeniu limitu czasu wynoszącym dziesięć sekund.The code example sends a message to a local message queue, then calls BeginReceive(TimeSpan), passing in a time-out value of ten seconds. Po wywołaniu zdarzenia ReceiveCompleted program obsługi zdarzeń odbiera komunikat i zapisuje treść komunikatu na ekranie.When a ReceiveCompleted event is raised, the event handler receives the message and writes the message body to the screen.

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

Uwagi

W przypadku przetwarzania asynchronicznego należy użyć BeginReceive, aby zgłosić zdarzenie ReceiveCompleted, gdy komunikat będzie dostępny w kolejce lub po upływie określonego interwału czasu.In asynchronous processing, you use BeginReceive to raise the ReceiveCompleted event when a message becomes available in the queue or when the specified interval of time has expired.

ReceiveCompleted jest również zgłaszane, jeśli komunikat już istnieje w kolejce.ReceiveCompleted is also raised if a message already exists in the queue.

Aby użyć BeginReceive, należy utworzyć procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i kojarzy ją z delegatem zdarzenia.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceive inicjuje asynchroniczną operację odbierania; MessageQueue zostaje powiadomiony przez podnoszenie poziomu zdarzenia ReceiveCompleted, gdy wiadomość dociera do kolejki.BeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. MessageQueue może następnie uzyskać dostęp do komunikatu, wywołując EndReceive(IAsyncResult) lub pobierając wynik przy użyciu ReceiveCompletedEventArgs.The MessageQueue can then access the message by calling EndReceive(IAsyncResult) or retrieving the result using the ReceiveCompletedEventArgs.

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie zakończona do momentu wywołania programu obsługi zdarzeń.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Ponieważ BeginReceive jest asynchroniczny, można wywołać go, aby odebrać komunikat z kolejki bez blokowania bieżącego wątku wykonywania.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Aby synchronicznie odebrać komunikat, użyj metody Receive.To synchronously receive a message, use the Receive method.

Po zakończeniu operacji asynchronicznej można wywołać BeginPeek lub BeginReceive ponownie w programie obsługi zdarzeń, aby nadal otrzymywać powiadomienia.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

Jeśli CanRead jest false, zostanie zgłoszone zdarzenie ukończenia, ale podczas wywoływania EndReceive(IAsyncResult)wystąpi wyjątek.If CanRead is false, the completion event is raised, but an exception will be thrown when calling EndReceive(IAsyncResult).

IAsyncResult, które BeginReceive zwraca, identyfikuje operację asynchroniczną, która została uruchomiona.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. Tej IAsyncResult można użyć w okresie istnienia operacji, chociaż zwykle nie jest używana do momentu wywołania metody EndReceive(IAsyncResult).You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Jeśli jednak uruchamiasz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy czekać na wszystkie operacje, czy dowolna operacja zostanie ukończona.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. W takim przypadku należy użyć właściwości AsyncWaitHandle IAsyncResult, aby zidentyfikować ukończoną operację.In this case, you use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

To Przeciążenie określa limit czasu. Jeśli interwał określony przez parametr timeout wygaśnie, ten składnik zgłasza zdarzenie ReceiveCompleted.This overload specifies a time-out. If the interval specified by the timeout parameter expires, this component raises the ReceiveCompleted event. Ponieważ żaden komunikat nie istnieje, kolejne wywołanie do EndReceive(IAsyncResult) spowoduje zgłoszenie wyjątku.Because no message exists, a subsequent call to EndReceive(IAsyncResult) will throw an exception.

Nie używaj wywołań asynchronicznych BeginReceive z transakcjami.Do not use the asynchronous call BeginReceive with transactions. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeeki umieść transakcję i metodę Receive (synchroniczna) w ramach procedury obsługi zdarzeń utworzonej dla operacji wglądu.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Program obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym C# kodzie.Your event handler might contain functionality as shown in the following C# code.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.The following table shows whether this method is available in various Workgroup modes.

Tryb grupy roboczejWorkgroup mode DostępneAvailable
Komputer lokalnyLocal computer TakYes
Nazwa komputera lokalnego i bezpośredniegoLocal computer and direct format name TakYes
Komputer zdalnyRemote computer NieNo
Nazwa komputera zdalnego i bezpośredniegoRemote computer and direct format name TakYes

Zobacz też

BeginReceive(TimeSpan, Object)

Inicjuje asynchroniczne operacje odbierania z określonym limitem czasu i określonym obiektem stanu, który zawiera skojarzone informacje w okresie istnienia operacji.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Parametry

timeout
TimeSpan

TimeSpan, który wskazuje interwał czasu oczekiwania na udostępnienie komunikatu.A TimeSpan that indicates the interval of time to wait for a message to become available.

stateObject
Object

Obiekt stanu określony przez aplikację, który zawiera informacje skojarzone z operacją asynchroniczną.A state object, specified by the application, that contains information associated with the asynchronous operation.

Zwraca

IAsyncResult

IAsyncResult, który identyfikuje ogłoszone żądanie asynchroniczne.The IAsyncResult that identifies the posted asynchronous request.

Wyjątki

Wartość określona dla parametru timeout jest nieprawidłowa.The value specified for the timeout parameter is not valid.

Wystąpił błąd podczas uzyskiwania dostępu do metody usługi kolejkowania komunikatów.An error occurred when accessing a Message Queuing method.

Przykłady

Poniższy przykład kodu tworzy asynchroniczną operację odbierania.The following code example creates an asynchronous receive operation. Przykładowy kod tworzy program obsługi zdarzeń, MyReceiveCompletedi dołącza go do delegata obsługi zdarzeń ReceiveCompleted.The code example creates an event handler, MyReceiveCompleted, and attaches it to the ReceiveCompleted event handler delegate. Przykładowy kod wysyła komunikat do lokalnej kolejki komunikatów, a następnie wywołuje BeginReceive(TimeSpan, Object), przekazując wartość w przekroczeniu limitu czasu wynoszącym dziesięć sekund i unikatową liczbę całkowitą, która identyfikuje określony komunikat.The code example sends a message to a local message queue, then calls BeginReceive(TimeSpan, Object), passing in a time-out value of ten seconds and a unique integer that identifies that particular message. Po podniesieniu zdarzenia ReceiveCompleted program obsługi zdarzeń odbiera komunikat i zapisuje treść komunikatu oraz identyfikator wiadomości liczb całkowitych na ekranie.When a ReceiveCompleted event is raised, the event handler receives the message and writes the message body and the integer message identifier to the screen.

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

Uwagi

W przypadku przetwarzania asynchronicznego należy użyć BeginReceive, aby zgłosić zdarzenie ReceiveCompleted, gdy komunikat będzie dostępny w kolejce lub po upływie określonego interwału czasu.In asynchronous processing, you use BeginReceive to raise the ReceiveCompleted event when a message becomes available in the queue or when the specified interval of time has expired.

ReceiveCompleted jest również zgłaszane, jeśli komunikat już istnieje w kolejce.ReceiveCompleted is also raised if a message already exists in the queue.

Użyj tego przeciążenia, aby skojarzyć informacje z operacją, która zostanie zachowana w okresie istnienia operacji.Use this overload to associate information with the operation that will be preserved throughout the operation's lifetime. Program obsługi zdarzeń może wykryć te informacje, przeglądając Właściwość AsyncState IAsyncResult, która jest skojarzona z operacją.The event handler can detect this information by looking at the AsyncState property of the IAsyncResult that is associated with the operation.

Aby użyć BeginReceive, należy utworzyć procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i kojarzy ją z delegatem zdarzenia.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceive inicjuje asynchroniczną operację odbierania; MessageQueue zostaje powiadomiony przez podnoszenie poziomu zdarzenia ReceiveCompleted, gdy wiadomość dociera do kolejki.BeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. MessageQueue może następnie uzyskać dostęp do komunikatu, wywołując EndReceive(IAsyncResult) lub pobierając wynik przy użyciu ReceiveCompletedEventArgs.The MessageQueue can then access the message by calling EndReceive(IAsyncResult) or retrieving the result using the ReceiveCompletedEventArgs.

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie zakończona do momentu wywołania programu obsługi zdarzeń.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Ponieważ BeginReceive jest asynchroniczny, można wywołać go, aby odebrać komunikat z kolejki bez blokowania bieżącego wątku wykonywania.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Aby synchronicznie odebrać komunikat, użyj metody Receive.To synchronously receive a message, use the Receive method.

Po zakończeniu operacji asynchronicznej można wywołać BeginPeek lub BeginReceive ponownie w programie obsługi zdarzeń, aby nadal otrzymywać powiadomienia.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

IAsyncResult, które BeginReceive zwraca, identyfikuje operację asynchroniczną, która została uruchomiona.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. Tej IAsyncResult można użyć w okresie istnienia operacji, chociaż zwykle nie jest używana do momentu wywołania metody EndReceive(IAsyncResult).You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Jeśli jednak uruchamiasz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy czekać na wszystkie operacje, czy dowolna operacja zostanie ukończona.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. W takim przypadku należy użyć właściwości AsyncWaitHandle IAsyncResult, aby zidentyfikować ukończoną operację.In this case, you use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

To Przeciążenie określa przekroczenie limitu czasu i obiektu stanu.This overload specifies a time-out and a state object. Jeśli interwał określony przez parametr timeout wygaśnie, ten składnik zgłasza zdarzenie ReceiveCompleted.If the interval specified by the timeout parameter expires, this component raises the ReceiveCompleted event. Ponieważ żaden komunikat nie istnieje, kolejne wywołanie do EndReceive(IAsyncResult) spowoduje zgłoszenie wyjątku.Because no message exists, a subsequent call to EndReceive(IAsyncResult) will throw an exception.

Obiekt State kojarzy informacje o stanie z operacją.The state object associates state information with the operation. Na przykład w przypadku wywołania BeginReceive wiele razy w celu zainicjowania wielu operacji można zidentyfikować każdą operację za pomocą oddzielnego obiektu stanu zdefiniowanego przez użytkownika.For example, if you call BeginReceive multiple times to initiate multiple operations, you can identify each operation through a separate state object that you define.

Można również użyć obiektu stanu do przekazywania informacji między wątkami procesów.You can also use the state object to pass information across process threads. Jeśli wątek jest uruchomiony, ale wywołanie zwrotne znajduje się w innym wątku w scenariuszu asynchronicznym, obiekt stanu jest zorganizowany i przekazywany z powrotem wraz z informacjami ze zdarzenia.If a thread is started but the callback is on a different thread in an asynchronous scenario, the state object is marshaled and passed back along with information from the event.

Nie używaj wywołań asynchronicznych BeginReceive z transakcjami.Do not use the asynchronous call BeginReceive with transactions. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeeki umieść transakcję i metodę Receive (synchroniczna) w ramach procedury obsługi zdarzeń utworzonej dla operacji wglądu.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Program obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym C# kodzie.Your event handler might contain functionality as shown in the following C# code.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.The following table shows whether this method is available in various Workgroup modes.

Tryb grupy roboczejWorkgroup mode DostępneAvailable
Komputer lokalnyLocal computer TakYes
Nazwa komputera lokalnego i bezpośredniegoLocal computer and direct format name TakYes
Komputer zdalnyRemote computer NieNo
Nazwa komputera zdalnego i bezpośredniegoRemote computer and direct format name TakYes

Zobacz też

BeginReceive(TimeSpan, Object, AsyncCallback)

Inicjuje asynchroniczne operacje odbierania z określonym limitem czasu i określonym obiektem stanu, który zawiera skojarzone informacje w okresie istnienia operacji.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. To Przeciążenie odbiera powiadomienie przy użyciu wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji.This overload receives notification, through a callback, of the identity of the event handler for the operation. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Parametry

timeout
TimeSpan

TimeSpan, który wskazuje interwał czasu oczekiwania na udostępnienie komunikatu.A TimeSpan that indicates the interval of time to wait for a message to become available.

stateObject
Object

Obiekt stanu określony przez aplikację, który zawiera informacje skojarzone z operacją asynchroniczną.A state object, specified by the application, that contains information associated with the asynchronous operation.

callback
AsyncCallback

AsyncCallback, które otrzyma powiadomienie o ukończeniu operacji asynchronicznej.The AsyncCallback that will receive the notification of the asynchronous operation completion.

Zwraca

IAsyncResult

IAsyncResult, który identyfikuje ogłoszone żądanie asynchroniczne.The IAsyncResult that identifies the posted asynchronous request.

Wyjątki

Wartość określona dla parametru timeout jest nieprawidłowa.The value specified for the timeout parameter is not valid.

Wystąpił błąd podczas uzyskiwania dostępu do metody usługi kolejkowania komunikatów.An error occurred when accessing a Message Queuing method.

Przykłady

Poniższy przykład kodu tworzy asynchroniczną operację odbierania.The following code example creates an asynchronous receive operation. Przykładowy kod wysyła komunikat do lokalnej kolejki komunikatów, a następnie wywołuje BeginReceive(TimeSpan, Object, AsyncCallback), przekazując w: wartość limitu czasu wynoszącą dziesięć sekund; Unikatowa liczba całkowita, która określa, że określony komunikat; i nowe wystąpienie AsyncCallback, które identyfikuje procedurę obsługi zdarzeń, MyReceiveCompleted.The code example sends a message to a local message queue, then calls BeginReceive(TimeSpan, Object, AsyncCallback), passing in: a time-out value of ten seconds; a unique integer that identifies that particular message; and a new instance of AsyncCallback that identifies the event handler, MyReceiveCompleted. Po podniesieniu zdarzenia ReceiveCompleted program obsługi zdarzeń odbiera komunikat i zapisuje treść komunikatu oraz identyfikator wiadomości liczb całkowitych na ekranie.When a ReceiveCompleted event is raised, the event handler receives the message and writes the message body and the integer message identifier to the screen.

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

Uwagi

W przypadku użycia tego przeciążenia wywołania zwrotne określone w parametrze wywołania zwrotnego są wywoływane bezpośrednio po udostępnieniu komunikatu w kolejce lub upływie określonego interwału czasu. zdarzenie ReceiveCompleted nie zostało zgłoszone.When you use this overload, the callback specified in the callback parameter is invoked directly when a message becomes available in the queue or when the specified interval of time has expired; the ReceiveCompleted event is not raised. Inne przeciążenia BeginReceive polegają na tym składniku do podniesienia ReceiveCompleted zdarzenia.The other overloads of BeginReceive rely on this component to raise the ReceiveCompleted event.

ReceiveCompleted jest również zgłaszane, jeśli komunikat już istnieje w kolejce.ReceiveCompleted is also raised if a message already exists in the queue.

Aby użyć BeginReceive, należy utworzyć procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i kojarzy ją z delegatem zdarzenia.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceive inicjuje asynchroniczną operację odbierania; MessageQueue zostaje powiadomiony przez podnoszenie poziomu zdarzenia ReceiveCompleted, gdy wiadomość dociera do kolejki.BeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. MessageQueue może następnie uzyskać dostęp do komunikatu, wywołując EndReceive(IAsyncResult) lub pobierając wynik przy użyciu ReceiveCompletedEventArgs.The MessageQueue can then access the message by calling EndReceive(IAsyncResult) or retrieving the result using the ReceiveCompletedEventArgs.

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie zakończona do momentu wywołania programu obsługi zdarzeń.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Ponieważ BeginReceive jest asynchroniczny, można wywołać go, aby odebrać komunikat z kolejki bez blokowania bieżącego wątku wykonywania.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Aby synchronicznie odebrać komunikat, użyj metody Receive.To synchronously receive a message, use the Receive method.

Po zakończeniu operacji asynchronicznej można wywołać BeginPeek lub BeginReceive ponownie w programie obsługi zdarzeń, aby nadal otrzymywać powiadomienia.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

IAsyncResult, które BeginReceive zwraca, identyfikuje operację asynchroniczną, która została uruchomiona.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. Tej IAsyncResult można użyć w okresie istnienia operacji, chociaż zwykle nie jest używana do momentu wywołania metody EndReceive(IAsyncResult).You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Jeśli jednak uruchamiasz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy czekać na wszystkie operacje, czy dowolna operacja zostanie ukończona.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. W takim przypadku należy użyć właściwości AsyncWaitHandle IAsyncResult, aby zidentyfikować ukończoną operację.In this case, you use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

Obiekt State kojarzy informacje o stanie z operacją.The state object associates state information with the operation. Na przykład w przypadku wywołania BeginReceive wiele razy w celu zainicjowania wielu operacji można zidentyfikować każdą operację za pomocą oddzielnego obiektu stanu zdefiniowanego przez użytkownika.For example, if you call BeginReceive multiple times to initiate multiple operations, you can identify each operation through a separate state object that you define.

Można również użyć obiektu stanu do przekazywania informacji między wątkami procesów.You can also use the state object to pass information across process threads. Jeśli wątek jest uruchomiony, ale wywołanie zwrotne znajduje się w innym wątku w scenariuszu asynchronicznym, obiekt stanu jest zorganizowany i przekazywany z powrotem wraz z informacjami ze zdarzenia.If a thread is started but the callback is on a different thread in an asynchronous scenario, the state object is marshaled and passed back along with information from the event.

Nie używaj wywołań asynchronicznych BeginReceive z transakcjami.Do not use the asynchronous call BeginReceive with transactions. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeeki umieść transakcję i metodę Receive (synchroniczna) w ramach procedury obsługi zdarzeń utworzonej dla operacji wglądu.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Program obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym C# kodzie.Your event handler might contain functionality as shown in the following C# code.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.The following table shows whether this method is available in various Workgroup modes.

Tryb grupy roboczejWorkgroup mode DostępneAvailable
Komputer lokalnyLocal computer TakYes
Nazwa komputera lokalnego i bezpośredniegoLocal computer and direct format name TakYes
Komputer zdalnyRemote computer NieNo
Nazwa komputera zdalnego i bezpośredniegoRemote computer and direct format name TakYes

Zobacz też

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu i używa określonego kursora i określonego obiektu stanu.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. Obiekt State zawiera powiązane informacje w okresie istnienia operacji.The state object provides associated information throughout the lifetime of the operation. To Przeciążenie odbiera powiadomienie przy użyciu wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji.This overload receives notification, through a callback, of the identity of the event handler for the operation. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Parametry

timeout
TimeSpan

TimeSpan, który wskazuje interwał czasu oczekiwania na udostępnienie komunikatu.A TimeSpan that indicates the interval of time to wait for a message to become available.

cursor
Cursor

Cursor, która zachowuje konkretną pozycję w kolejce komunikatów.A Cursor that maintains a specific position in the message queue.

state
Object

Obiekt stanu określony przez aplikację, który zawiera informacje skojarzone z operacją asynchroniczną.A state object, specified by the application, that contains information associated with the asynchronous operation.

callback
AsyncCallback

AsyncCallback, który odbiera powiadomienie o ukończeniu operacji asynchronicznej.The AsyncCallback that receives the notification of the asynchronous operation completion.

Zwraca

IAsyncResult

IAsyncResult, który identyfikuje ogłoszone żądanie asynchroniczne.The IAsyncResult that identifies the posted asynchronous request.

Wyjątki

Parametr cursor ma wartość null.The cursor parameter is null.

Wartość określona dla parametru timeout jest nieprawidłowa.The value specified for the timeout parameter is not valid.

Wystąpił błąd podczas uzyskiwania dostępu do metody usługi kolejkowania komunikatów.An error occurred when accessing a Message Queuing method.

Uwagi

W przypadku użycia tego przeciążenia wywołania zwrotne określone w parametrze wywołania zwrotnego są wywoływane bezpośrednio po udostępnieniu komunikatu w kolejce lub upływie określonego interwału czasu. zdarzenie ReceiveCompleted nie zostało zgłoszone.When you use this overload, the callback specified in the callback parameter is invoked directly when a message becomes available in the queue or when the specified interval of time has expired; the ReceiveCompleted event is not raised. Inne przeciążenia BeginReceive polegają na tym składniku do podniesienia ReceiveCompleted zdarzenia.The other overloads of BeginReceive rely on this component to raise the ReceiveCompleted event.

ReceiveCompleted jest również zgłaszane, jeśli komunikat już istnieje w kolejce.ReceiveCompleted is also raised if a message already exists in the queue.

Aby użyć BeginReceive, należy utworzyć procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i kojarzy ją z delegatem zdarzenia.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceive inicjuje asynchroniczną operację odbierania; MessageQueue zostaje powiadomiony przez podnoszenie poziomu zdarzenia ReceiveCompleted, gdy wiadomość dociera do kolejki.BeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. MessageQueue może następnie uzyskać dostęp do komunikatu, wywołując EndReceive(IAsyncResult) lub pobierając wynik przy użyciu ReceiveCompletedEventArgs.The MessageQueue can then access the message by calling EndReceive(IAsyncResult) or retrieving the result using the ReceiveCompletedEventArgs.

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie zakończona do momentu wywołania programu obsługi zdarzeń.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Ponieważ BeginReceive jest asynchroniczny, można wywołać go, aby odebrać komunikat z kolejki bez blokowania bieżącego wątku wykonywania.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Aby synchronicznie odebrać komunikat, użyj metody Receive.To synchronously receive a message, use the Receive method.

Po zakończeniu operacji asynchronicznej można wywołać BeginPeek lub BeginReceive ponownie w programie obsługi zdarzeń, aby nadal otrzymywać powiadomienia.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

IAsyncResult, które BeginReceive zwraca, identyfikuje operację asynchroniczną, która została uruchomiona.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. Tej IAsyncResult można użyć w okresie istnienia operacji, chociaż zwykle nie jest używana do momentu wywołania metody EndReceive(IAsyncResult).You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Jeśli jednak uruchamiasz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy czekać na wszystkie operacje, czy dowolna operacja zostanie ukończona.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. W takim przypadku należy użyć właściwości AsyncWaitHandle IAsyncResult, aby zidentyfikować ukończoną operację.In this case, use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

Obiekt State kojarzy informacje o stanie z operacją.The state object associates state information with the operation. Na przykład w przypadku wywołania BeginReceive wiele razy w celu zainicjowania wielu operacji można zidentyfikować każdą operację za pomocą oddzielnego obiektu stanu zdefiniowanego przez użytkownika.For example, if you call BeginReceive multiple times to initiate multiple operations, you can identify each operation through a separate state object that you define.

Można również użyć obiektu stanu do przekazywania informacji między wątkami procesów.You can also use the state object to pass information across process threads. Jeśli wątek jest uruchomiony, ale wywołanie zwrotne znajduje się w innym wątku w scenariuszu asynchronicznym, obiekt stanu jest zorganizowany i przekazywany z powrotem wraz z informacjami ze zdarzenia.If a thread is started but the callback is on a different thread in an asynchronous scenario, the state object is marshaled and passed back along with information from the event.

Nie używaj wywołań asynchronicznych BeginReceive z transakcjami.Do not use the asynchronous call BeginReceive with transactions. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeeki umieść transakcję i metodę Receive (synchroniczna) w ramach procedury obsługi zdarzeń utworzonej dla operacji wglądu.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Program obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym C# kodzie.Your event handler might contain functionality as shown in the following C# code.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.The following table shows whether this method is available in various Workgroup modes.

Tryb grupy roboczejWorkgroup mode DostępneAvailable
Komputer lokalnyLocal computer TakYes
Nazwa komputera lokalnego i bezpośredniegoLocal computer and direct format name TakYes
Komputer zdalnyRemote computer NieNo
Nazwa komputera zdalnego i bezpośredniegoRemote computer and direct format name TakYes

Zobacz też

Dotyczy

Bezpieczeństwo wątkowe

Metoda nie jest bezpieczna wątkowo.The method is not thread safe.