MessageQueue.BeginReceive Metoda

Definicja

Inicjuje asynchroniczną operację odbierania, informując kolejkę komunikatów o rozpoczęciu odbierania komunikatu i powiadamianiu programu obsługi zdarzeń po zakończeniu.

Przeciążenia

BeginReceive()

Inicjuje asynchroniczną operację odbierania, która nie ma limitu czasu. Operacja nie zostanie ukończona, dopóki komunikat nie stanie się dostępny w kolejce.

BeginReceive(TimeSpan)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

BeginReceive(TimeSpan, Object)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w całym okresie istnienia operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

BeginReceive(TimeSpan, Object, AsyncCallback)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w całym okresie istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

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. Obiekt stanu dostarcza skojarzone informacje przez cały okres istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

BeginReceive()

Inicjuje asynchroniczną operację odbierania, która nie ma limitu czasu. Operacja nie zostanie ukończona, dopóki komunikat nie stanie się dostępny w kolejce.

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

Zwraca

IAsyncResult

Element IAsyncResult , który identyfikuje przesłane żądanie asynchroniczne.

Wyjątki

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu powoduje łańcuch asynchronicznych żądań. Przyjęto założenie, że na komputerze lokalnym znajduje się kolejka o nazwie "myQueue". Funkcja Main rozpoczyna operację asynchroniczną obsługiwaną przez procedurę MyReceiveCompleted . MyReceiveCompleted przetwarza bieżący komunikat i rozpoczyna nową asynchroniczną operację odbierania.

#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 żądania asynchroniczne. Wywołanie metody , aby używać BeginReceiveAsyncWaitHandle wartości w zwracanej wartości. Procedura Main czeka na ukończenie wszystkich operacji asynchronicznych przed zakończeniem.

#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 polecenia , aby zgłosić ReceiveCompleted zdarzenie po usunięciu komunikatu z kolejki.

ReceiveCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Aby użyć polecenia BeginReceive, utwórz procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i kojarzy ją z pełnomocnikiem zdarzenia. BeginReceive inicjuje asynchroniczną operację odbierania; MessageQueue element jest powiadamiany przez wywoływanie ReceiveCompleted zdarzenia po nadejściu komunikatu w kolejce. Następnie MessageQueue można uzyskać dostęp do wiadomości przez wywołanie metody EndReceive(IAsyncResult).

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginReceive jest asynchroniczna, można wywołać ją, aby odbierać komunikat z kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie odbierać komunikat, użyj Receive metody .

Po zakończeniu operacji asynchronicznej można wywołać BeginPeek lub BeginReceive ponownie w programie obsługi zdarzeń, aby otrzymywać powiadomienia.

Funkcja IAsyncResult , która BeginReceive zwraca, identyfikuje operację asynchroniczną uruchomioną przez metodę. Można go IAsyncResult używać przez cały okres istnienia operacji, chociaż zwykle nie należy jej używać, dopóki EndReceive(IAsyncResult) nie zostanie wywołana. Jeśli jednak uruchomisz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy zaczekać na zakończenie wszystkich operacji, czy dowolnej operacji. W tym przypadku użyjesz AsyncWaitHandle właściwości , IAsyncResult aby zidentyfikować ukończoną operację.

Jeśli CanRead parametr ma falsewartość , zdarzenie ukończenia zostanie zgłoszone, ale podczas wywoływania EndReceive(IAsyncResult)metody zostanie zgłoszony wyjątek .

Nie używaj wywołania BeginReceive asynchronicznego z transakcjami. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeekmetodę , a następnie umieść transakcję i metodę (synchroniczną) Receive w procedurze obsługi zdarzeń utworzonej dla operacji wglądu. Procedura obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym kodzie języka C#.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej Dostępne
Komputer lokalny Tak
Nazwa komputera lokalnego i bezpośredniego formatu Tak
Komputer zdalny Nie
Nazwa komputera zdalnego i bezpośredniego formatu Tak

Zobacz też

Dotyczy

BeginReceive(TimeSpan)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

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

Element TimeSpan wskazujący przedział czasu oczekiwania na udostępnienie komunikatu.

Zwraca

IAsyncResult

Element IAsyncResult identyfikujący wysłaną asynchroniczną prośbę.

Wyjątki

Wartość określona dla parametru timeout jest nieprawidłowa, prawdopodobnie dlatego, że reprezentuje liczbę ujemną.

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu tworzy asynchroniczną operację odbierania. Przykładowy kod tworzy procedurę obsługi MyReceiveCompletedzdarzeń i dołącza ją do delegata ReceiveCompleted programu obsługi zdarzeń. Przykładowy kod wysyła komunikat do lokalnej kolejki komunikatów, a następnie wywołuje BeginReceive(TimeSpan)metodę , przekazując wartość limitu czasu 10 sekund. Po wystąpieniu ReceiveCompleted zdarzenia program obsługi zdarzeń odbiera komunikat i zapisuje treść komunikatu na ekranie.

#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 polecenia , aby zgłosić ReceiveCompleted zdarzenie, gdy komunikat stanie się dostępny w kolejce lub gdy określony interwał czasu wygasł.

ReceiveCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Aby użyć polecenia BeginReceive, utwórz procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i kojarzy ją z pełnomocnikiem zdarzenia. BeginReceive inicjuje asynchroniczną operację odbierania; MessageQueue element jest powiadamiany przez wywoływanie ReceiveCompleted zdarzenia po nadejściu komunikatu w kolejce. Element MessageQueue może następnie uzyskać dostęp do wiadomości przez wywołanie EndReceive(IAsyncResult) lub pobranie wyniku przy użyciu elementu ReceiveCompletedEventArgs.

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginReceive jest asynchroniczna, można wywołać ją, aby odbierać komunikat z kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie odbierać komunikat, użyj Receive metody .

Po zakończeniu operacji asynchronicznej można wywołać BeginPeek lub BeginReceive ponownie w programie obsługi zdarzeń, aby otrzymywać powiadomienia.

Jeśli CanRead parametr ma falsewartość , zdarzenie ukończenia zostanie zgłoszone, ale podczas wywoływania EndReceive(IAsyncResult)metody zostanie zgłoszony wyjątek .

Funkcja IAsyncResult , która BeginReceive zwraca, identyfikuje operację asynchroniczną uruchomioną przez metodę. Można go IAsyncResult używać przez cały okres istnienia operacji, chociaż zwykle nie należy jej używać, dopóki EndReceive(IAsyncResult) nie zostanie wywołana. Jeśli jednak uruchomisz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy zaczekać na zakończenie wszystkich operacji, czy dowolnej operacji. W tym przypadku użyjesz AsyncWaitHandle właściwości , IAsyncResult aby zidentyfikować ukończoną operację.

To przeciążenie określa limit czasu. Jeśli interwał określony przez timeout parametr wygaśnie, ten składnik zgłasza ReceiveCompleted zdarzenie. Ponieważ żaden komunikat nie istnieje, kolejne wywołanie EndReceive(IAsyncResult) metody zgłosi wyjątek.

Nie używaj wywołania BeginReceive asynchronicznego z transakcjami. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeekmetodę , a następnie umieść transakcję i metodę (synchroniczną) Receive w procedurze obsługi zdarzeń utworzonej dla operacji wglądu. Procedura obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym kodzie języka C#.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej Dostępne
Komputer lokalny Tak
Nazwa komputera lokalnego i bezpośredniego formatu Tak
Komputer zdalny Nie
Nazwa komputera zdalnego i bezpośredniego formatu Tak

Zobacz też

Dotyczy

BeginReceive(TimeSpan, Object)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w całym okresie istnienia operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

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

Element TimeSpan wskazujący interwał czasu oczekiwania na udostępnienie komunikatu.

stateObject
Object

Obiekt stanu określony przez aplikację, który zawiera informacje skojarzone z operacją asynchroniczną.

Zwraca

IAsyncResult

Element IAsyncResult identyfikujący wysłaną asynchroniczną prośbę.

Wyjątki

Wartość określona dla parametru timeout jest nieprawidłowa.

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu tworzy asynchroniczną operację odbierania. Przykładowy kod tworzy procedurę obsługi MyReceiveCompletedzdarzeń i dołącza ją do delegata ReceiveCompleted procedury obsługi zdarzeń. Przykładowy kod wysyła komunikat do lokalnej kolejki komunikatów, a następnie wywołuje BeginReceive(TimeSpan, Object)metodę , przekazując wartość limitu czasu dziesięć sekund i unikatową liczbę całkowitą identyfikującą ten konkretny komunikat. ReceiveCompleted Po wystąpieniu zdarzenia program obsługi zdarzeń odbiera komunikat i zapisuje treść komunikatu oraz identyfikator komunikatu całkowitego na ekranie.

#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 polecenia , aby zgłosić ReceiveCompleted zdarzenie, gdy komunikat stanie się dostępny w kolejce lub gdy określony interwał czasu wygasł.

ReceiveCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Użyj tego przeciążenia, aby skojarzyć informacje z operacją, która zostanie zachowana przez cały okres istnienia operacji. Program obsługi zdarzeń może wykryć te informacje, przeglądając AsyncState właściwość IAsyncResult obiektu skojarzonego z operacją.

Aby użyć BeginReceivemetody , utwórz procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i skojarz ją z delegatem zdarzenia. BeginReceive inicjuje asynchroniczną operację odbierania; komunikat MessageQueue jest powiadamiany przez podniesienie ReceiveCompleted zdarzenia po nadejściu komunikatu w kolejce. Następnie MessageQueue może uzyskać dostęp do wiadomości przez wywołanie EndReceive(IAsyncResult) lub pobranie wyniku przy użyciu polecenia ReceiveCompletedEventArgs.

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginReceive jest asynchroniczna, można wywołać ją w celu odebrania komunikatu z kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie odebrać komunikat, użyj Receive metody .

Po zakończeniu operacji asynchronicznej można wywołać program BeginPeek obsługi zdarzeń lub BeginReceive ponownie, aby otrzymywać powiadomienia.

Funkcja IAsyncResult , która BeginReceive zwraca, identyfikuje operację asynchroniczną uruchomioną przez metodę. Można go IAsyncResult używać przez cały okres istnienia operacji, chociaż zazwyczaj nie używasz jej do EndReceive(IAsyncResult) momentu wywołania. Jeśli jednak rozpoczniesz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy zaczekać na ukończenie wszystkich operacji, czy jakąkolwiek operację. W takim przypadku należy użyć AsyncWaitHandle właściwości elementu IAsyncResult , aby zidentyfikować ukończoną operację.

To przeciążenie określa limit czasu i obiekt stanu. Jeśli interwał określony przez timeout parametr wygaśnie, ten składnik zgłasza ReceiveCompleted zdarzenie. Ponieważ żaden komunikat nie istnieje, kolejne wywołanie wywołania EndReceive(IAsyncResult) zgłosi wyjątek.

Obiekt stanu kojarzy informacje o stanie z operacją. Jeśli na przykład wywołasz wiele BeginReceive razy w celu zainicjowania wielu operacji, możesz zidentyfikować każdą operację za pomocą oddzielnego obiektu stanu, który definiujesz.

Można również użyć obiektu stanu, aby przekazać informacje między wątkami procesu. Jeśli wątek zostanie uruchomiony, ale wywołanie zwrotne znajduje się w innym wątku w scenariuszu asynchronicznym, obiekt stanu jest marshalowany i przekazywany z powrotem wraz z informacjami z zdarzenia.

Nie używaj wywołania BeginReceive asynchronicznego z transakcjami. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeekmetodę , i umieść transakcję oraz metodę (synchroniczną) Receive w procedurze obsługi zdarzeń utworzonej dla operacji wglądu. Procedura obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym kodzie języka C#.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej Dostępne
Komputer lokalny Tak
Komputer lokalny i nazwa formatu bezpośredniego Tak
Komputer zdalny Nie
Nazwa komputera zdalnego i formatu bezpośredniego Tak

Zobacz też

Dotyczy

BeginReceive(TimeSpan, Object, AsyncCallback)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w całym okresie istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

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

Element TimeSpan wskazujący interwał czasu oczekiwania na udostępnienie komunikatu.

stateObject
Object

Obiekt stanu określony przez aplikację, który zawiera informacje skojarzone z operacją asynchroniczną.

callback
AsyncCallback

Element AsyncCallback , który otrzyma powiadomienie o zakończeniu operacji asynchronicznej.

Zwraca

IAsyncResult

Element IAsyncResult identyfikujący wysłaną asynchroniczną prośbę.

Wyjątki

Wartość określona dla parametru timeout jest nieprawidłowa.

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu tworzy asynchroniczną operację odbierania. Przykładowy kod wysyła komunikat do lokalnej kolejki komunikatów, a następnie wywołuje BeginReceive(TimeSpan, Object, AsyncCallback)metodę , przekazując: wartość limitu czasu wynoszącą dziesięć sekund; unikatową liczbę całkowitą, która identyfikuje ten konkretny komunikat, oraz nowe wystąpienie, które identyfikuje procedurę obsługi zdarzeńAsyncCallback. MyReceiveCompleted ReceiveCompleted Po wystąpieniu zdarzenia program obsługi zdarzeń odbiera komunikat i zapisuje treść komunikatu oraz identyfikator komunikatu całkowitego na ekranie.

#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

Gdy używasz tego przeciążenia, wywołanie zwrotne określone w parametrze wywołania zwrotnego jest wywoływane bezpośrednio, gdy komunikat stanie się dostępny w kolejce lub gdy określony interwał czasu wygasł; zdarzenie ReceiveCompleted nie jest zgłaszane. Inne przeciążenia polegają na tym składniku BeginReceiveReceiveCompleted w celu podniesienia zdarzenia.

ReceiveCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Aby użyć BeginReceivemetody , utwórz procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i skojarz ją z delegatem zdarzenia. BeginReceive inicjuje asynchroniczną operację odbierania; komunikat MessageQueue jest powiadamiany przez podniesienie ReceiveCompleted zdarzenia po nadejściu komunikatu w kolejce. Następnie MessageQueue może uzyskać dostęp do wiadomości przez wywołanie EndReceive(IAsyncResult) lub pobranie wyniku przy użyciu polecenia ReceiveCompletedEventArgs.

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginReceive jest asynchroniczna, można wywołać ją w celu odebrania komunikatu z kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie odebrać komunikat, użyj Receive metody .

Po zakończeniu operacji asynchronicznej można wywołać program BeginPeek obsługi zdarzeń lub BeginReceive ponownie, aby otrzymywać powiadomienia.

Funkcja IAsyncResult , która BeginReceive zwraca, identyfikuje operację asynchroniczną uruchomioną przez metodę. Można go IAsyncResult używać przez cały okres istnienia operacji, chociaż zazwyczaj nie używasz jej do EndReceive(IAsyncResult) momentu wywołania. Jeśli jednak rozpoczniesz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy zaczekać na ukończenie wszystkich operacji, czy jakąkolwiek operację. W takim przypadku należy użyć AsyncWaitHandle właściwości elementu IAsyncResult , aby zidentyfikować ukończoną operację.

Obiekt stanu kojarzy informacje o stanie z operacją. Jeśli na przykład wywołasz wiele BeginReceive razy w celu zainicjowania wielu operacji, możesz zidentyfikować każdą operację za pomocą oddzielnego obiektu stanu, który definiujesz.

Można również użyć obiektu stanu, aby przekazać informacje między wątkami procesu. Jeśli wątek zostanie uruchomiony, ale wywołanie zwrotne znajduje się w innym wątku w scenariuszu asynchronicznym, obiekt stanu jest marshalowany i przekazywany z powrotem wraz z informacjami z zdarzenia.

Nie używaj wywołania BeginReceive asynchronicznego z transakcjami. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeekmetodę , i umieść transakcję oraz metodę (synchroniczną) Receive w procedurze obsługi zdarzeń utworzonej dla operacji wglądu. Procedura obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym kodzie języka C#.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej Dostępne
Komputer lokalny Tak
Komputer lokalny i nazwa formatu bezpośredniego Tak
Komputer zdalny Nie
Nazwa komputera zdalnego i formatu bezpośredniego Tak

Zobacz też

Dotyczy

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. Obiekt stanu udostępnia skojarzone informacje przez cały okres istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

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

Element TimeSpan wskazujący interwał czasu oczekiwania na udostępnienie komunikatu.

cursor
Cursor

Element Cursor , który utrzymuje określoną pozycję w kolejce komunikatów.

state
Object

Obiekt stanu określony przez aplikację, który zawiera informacje skojarzone z operacją asynchroniczną.

callback
AsyncCallback

Element AsyncCallback , który otrzymuje powiadomienie o zakończeniu operacji asynchronicznej.

Zwraca

IAsyncResult

Element IAsyncResult identyfikujący wysłaną asynchroniczną prośbę.

Wyjątki

Parametr cursor to null.

Wartość określona dla parametru timeout jest nieprawidłowa.

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Uwagi

Gdy używasz tego przeciążenia, wywołanie zwrotne określone w parametrze wywołania zwrotnego jest wywoływane bezpośrednio, gdy komunikat stanie się dostępny w kolejce lub gdy określony interwał czasu wygasł; zdarzenie ReceiveCompleted nie jest zgłaszane. Inne przeciążenia polegają na tym składniku BeginReceiveReceiveCompleted w celu podniesienia zdarzenia.

ReceiveCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Aby użyć BeginReceivemetody , utwórz procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i skojarz ją z delegatem zdarzenia. BeginReceive inicjuje asynchroniczną operację odbierania; komunikat MessageQueue jest powiadamiany przez podniesienie ReceiveCompleted zdarzenia po nadejściu komunikatu w kolejce. Następnie MessageQueue może uzyskać dostęp do wiadomości przez wywołanie EndReceive(IAsyncResult) lub pobranie wyniku przy użyciu polecenia ReceiveCompletedEventArgs.

Metoda BeginReceive zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginReceive jest asynchroniczna, można wywołać ją w celu odebrania komunikatu z kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie odebrać komunikat, użyj Receive metody .

Po zakończeniu operacji asynchronicznej można wywołać program BeginPeek obsługi zdarzeń lub BeginReceive ponownie, aby otrzymywać powiadomienia.

Funkcja IAsyncResult , która BeginReceive zwraca, identyfikuje operację asynchroniczną uruchomioną przez metodę. Można go IAsyncResult używać przez cały okres istnienia operacji, chociaż zazwyczaj nie używasz jej do EndReceive(IAsyncResult) momentu wywołania. Jeśli jednak rozpoczniesz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy zaczekać na ukończenie wszystkich operacji, czy jakąkolwiek operację. W tym przypadku użyj AsyncWaitHandle właściwości elementu IAsyncResult , aby zidentyfikować ukończoną operację.

Obiekt stanu kojarzy informacje o stanie z operacją. Jeśli na przykład wywołasz wiele BeginReceive razy w celu zainicjowania wielu operacji, możesz zidentyfikować każdą operację za pomocą oddzielnego obiektu stanu, który definiujesz.

Można również użyć obiektu stanu, aby przekazać informacje między wątkami procesu. Jeśli wątek zostanie uruchomiony, ale wywołanie zwrotne znajduje się w innym wątku w scenariuszu asynchronicznym, obiekt stanu jest marshalowany i przekazywany z powrotem wraz z informacjami z zdarzenia.

Nie używaj wywołania BeginReceive asynchronicznego z transakcjami. Jeśli chcesz wykonać transakcyjną operację asynchroniczną, wywołaj BeginPeekmetodę , i umieść transakcję oraz metodę (synchroniczną) Receive w procedurze obsługi zdarzeń utworzonej dla operacji wglądu. Procedura obsługi zdarzeń może zawierać funkcje, jak pokazano w poniższym kodzie języka C#.

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

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej Dostępne
Komputer lokalny Tak
Komputer lokalny i nazwa formatu bezpośredniego Tak
Komputer zdalny Nie
Nazwa komputera zdalnego i formatu bezpośredniego Tak

Zobacz też

Dotyczy

Bezpieczeństwo wątkowe

Metoda nie jest bezpieczna wątkiem.