MessageQueue.BeginReceive Método

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Retornos

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

Exemplos

O exemplo de código a seguir encadeia solicitações assíncronas. Ele pressupõe que há uma fila no computador local chamada "myQueue". A Main função inicia a operação assíncrona que é tratada pela MyReceiveCompleted rotina. MyReceiveCompleted processa a mensagem atual e inicia uma nova operação de recebimento assíncrono.

#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

O exemplo de código a seguir enfileira solicitações assíncronas. A chamada para BeginReceive usar o AsyncWaitHandle valor retornado. A Main rotina aguarda que todas as operações assíncronas sejam concluídas antes de sair.

#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

Comentários

No processamento assíncrono, você usa BeginReceive para acionar o ReceiveCompleted evento quando uma mensagem é removida da fila.

ReceiveCompleted também será gerado se uma mensagem já existir na fila.

Para usar BeginReceive, crie um manipulador de eventos que processe os resultados da operação assíncrona e associe-o ao delegado de eventos. BeginReceive inicia uma operação de recebimento assíncrono; o MessageQueue é notificado, por meio da elevação do ReceiveCompleted evento, quando uma mensagem chega na fila. Em MessageQueue seguida, é possível acessar a mensagem chamando EndReceive(IAsyncResult).

O BeginReceive método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginReceive é assíncrono, você pode chamá-la para receber uma mensagem da fila sem bloquear o thread atual de execução. Para receber uma mensagem de forma síncrona, use o Receive método.

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona iniciada pelo método. Você pode usá-lo IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndReceive(IAsyncResult) ser chamada. No entanto, se você iniciar várias operações assíncronas, poderá colocar seus IAsyncResult valores em uma matriz e especificar se deseja aguardar a conclusão de todas as operações ou de qualquer operação. Nesse caso, você usa a AsyncWaitHandle propriedade do IAsyncResult para identificar a operação concluída.

Se CanRead for false, o evento de conclusão será gerado, mas uma exceção será gerada ao chamar EndReceive(IAsyncResult).

Não use a chamada BeginReceive assíncrona com transações. Se você quiser executar uma operação assíncrona transacional, chame BeginPeeke coloque a transação e o método (síncrono) Receive no manipulador de eventos criado para a operação de espiar. O manipulador de eventos pode conter funcionalidade, conforme mostrado no código C# a seguir.

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

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);

public IAsyncResult BeginReceive(TimeSpan timeout);

member this.BeginReceive : TimeSpan -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

Parâmetros

Retornos

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

Exemplos

O exemplo de código a seguir cria uma operação de recebimento assíncrona. O exemplo de código cria um manipulador MyReceiveCompletedde eventos e o anexa ao delegado do ReceiveCompleted manipulador de eventos. O exemplo de código envia uma mensagem para uma fila de mensagens local e, em seguida, chamadas BeginReceive(TimeSpan), passando um valor de tempo limite de dez segundos. Quando um ReceiveCompleted evento é acionado, o manipulador de eventos recebe a mensagem e grava o corpo da mensagem na tela.

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

Comentários

No processamento assíncrono, você usa BeginReceive para acionar o ReceiveCompleted evento quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expirou.

ReceiveCompleted também será gerado se uma mensagem já existir na fila.

Para usar BeginReceive, crie um manipulador de eventos que processe os resultados da operação assíncrona e associe-o ao delegado de eventos. BeginReceive inicia uma operação de recebimento assíncrono; o MessageQueue é notificado, por meio da elevação do ReceiveCompleted evento, quando uma mensagem chega na fila. Em MessageQueue seguida, é possível acessar a mensagem chamando EndReceive(IAsyncResult) ou recuperando o resultado usando o ReceiveCompletedEventArgs.

O BeginReceive método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginReceive é assíncrono, você pode chamá-la para receber uma mensagem da fila sem bloquear o thread atual de execução. Para receber uma mensagem de forma síncrona, use o Receive método.

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

Se CanRead for false, o evento de conclusão será gerado, mas uma exceção será gerada ao chamar EndReceive(IAsyncResult).

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona iniciada pelo método. Você pode usá-lo IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndReceive(IAsyncResult) ser chamada. No entanto, se você iniciar várias operações assíncronas, poderá colocar seus IAsyncResult valores em uma matriz e especificar se deseja aguardar a conclusão de todas as operações ou de qualquer operação. Nesse caso, você usa a AsyncWaitHandle propriedade do IAsyncResult para identificar a operação concluída.

Essa sobrecarga especifica um tempo limite. Se o intervalo especificado pelo timeout parâmetro expirar, esse componente gerará o ReceiveCompleted evento. Como nenhuma mensagem existe, uma chamada subsequente gerará EndReceive(IAsyncResult) uma exceção.

Não use a chamada BeginReceive assíncrona com transações. Se você quiser executar uma operação assíncrona transacional, chame BeginPeeke coloque a transação e o método (síncrono) Receive no manipulador de eventos criado para a operação de espiar. O manipulador de eventos pode conter funcionalidade, conforme mostrado no código C# a seguir.

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

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject);

public IAsyncResult BeginReceive(TimeSpan timeout, object stateObject);

member this.BeginReceive : TimeSpan * obj -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan, stateObject As Object) As IAsyncResult

Parâmetros

Retornos

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

Exemplos

O exemplo de código a seguir cria uma operação de recebimento assíncrona. O exemplo de código cria um manipulador MyReceiveCompletedde eventos e o anexa ao delegado do ReceiveCompleted manipulador de eventos. O exemplo de código envia uma mensagem para uma fila de mensagens local, em seguida, chamadas BeginReceive(TimeSpan, Object), passando um valor de tempo limite de dez segundos e um inteiro exclusivo que identifica essa mensagem específica. Quando um ReceiveCompleted evento é acionado, o manipulador de eventos recebe a mensagem e grava o corpo da mensagem e o identificador de mensagem inteiro na tela.

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

Comentários

No processamento assíncrono, você usa BeginReceive para acionar o ReceiveCompleted evento quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expirou.

ReceiveCompleted também será gerado se uma mensagem já existir na fila.

Use essa sobrecarga para associar informações à operação que serão preservadas durante todo o tempo de vida da operação. O manipulador de eventos pode detectar essas informações examinando a AsyncState propriedade da IAsyncResult que está associada à operação.

Para usar BeginReceive, crie um manipulador de eventos que processe os resultados da operação assíncrona e associe-o ao delegado de eventos. BeginReceive inicia uma operação de recebimento assíncrono; o MessageQueue é notificado, por meio da elevação do ReceiveCompleted evento, quando uma mensagem chega na fila. Em MessageQueue seguida, é possível acessar a mensagem chamando EndReceive(IAsyncResult) ou recuperando o resultado usando o ReceiveCompletedEventArgs.

O BeginReceive método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginReceive é assíncrono, você pode chamá-la para receber uma mensagem da fila sem bloquear o thread atual de execução. Para receber uma mensagem de forma síncrona, use o Receive método.

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona iniciada pelo método. Você pode usá-lo IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndReceive(IAsyncResult) ser chamada. No entanto, se você iniciar várias operações assíncronas, poderá colocar seus IAsyncResult valores em uma matriz e especificar se deseja aguardar a conclusão de todas as operações ou de qualquer operação. Nesse caso, você usa a AsyncWaitHandle propriedade do IAsyncResult para identificar a operação concluída.

Essa sobrecarga especifica um tempo limite e um objeto de estado. Se o intervalo especificado pelo timeout parâmetro expirar, esse componente gerará o ReceiveCompleted evento. Como nenhuma mensagem existe, uma chamada subsequente gerará EndReceive(IAsyncResult) uma exceção.

O objeto state associa informações de estado à operação. Por exemplo, se você chamar BeginReceive várias vezes para iniciar várias operações, poderá identificar cada operação por meio de um objeto de estado separado definido.

Você também pode usar o objeto de estado para passar informações entre threads de processo. Se um thread for iniciado, mas o retorno de chamada estiver em um thread diferente em um cenário assíncrono, o objeto de estado será marshalado e passado de volta junto com as informações do evento.

Não use a chamada BeginReceive assíncrona com transações. Se você quiser executar uma operação assíncrona transacional, chame BeginPeeke coloque a transação e o método (síncrono) Receive no manipulador de eventos criado para a operação de espiar. O manipulador de eventos pode conter funcionalidade, conforme mostrado no código C# a seguir.

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

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);

public IAsyncResult BeginReceive(TimeSpan timeout, object stateObject, AsyncCallback callback);

member this.BeginReceive : TimeSpan * obj * AsyncCallback -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan, stateObject As Object, callback As AsyncCallback) As IAsyncResult

Parâmetros

Retornos

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

Exemplos

O exemplo de código a seguir cria uma operação de recebimento assíncrona. O exemplo de código envia uma mensagem para uma fila de mensagens local e, em seguida, chamaBeginReceive(TimeSpan, Object, AsyncCallback), passando: um valor de tempo limite de dez segundos; um inteiro exclusivo que identifica essa mensagem específica; e uma nova instância dele identifica o manipulador de AsyncCallback eventos. MyReceiveCompleted Quando um ReceiveCompleted evento é acionado, o manipulador de eventos recebe a mensagem e grava o corpo da mensagem e o identificador de mensagem inteiro na tela.

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

Comentários

Quando você usa essa sobrecarga, o retorno de chamada especificado no parâmetro de retorno de chamada é invocado diretamente quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expirou; o ReceiveCompleted evento não é gerado. As outras sobrecargas de BeginReceive depender desse componente para gerar o ReceiveCompleted evento.

ReceiveCompleted também será gerado se uma mensagem já existir na fila.

Para usar BeginReceive, crie um manipulador de eventos que processe os resultados da operação assíncrona e associe-o ao delegado de eventos. BeginReceive inicia uma operação de recebimento assíncrono; o MessageQueue é notificado, por meio da elevação do ReceiveCompleted evento, quando uma mensagem chega na fila. Em MessageQueue seguida, é possível acessar a mensagem chamando EndReceive(IAsyncResult) ou recuperando o resultado usando o ReceiveCompletedEventArgs.

O BeginReceive método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginReceive é assíncrono, você pode chamá-la para receber uma mensagem da fila sem bloquear o thread atual de execução. Para receber uma mensagem de forma síncrona, use o Receive método.

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona iniciada pelo método. Você pode usá-lo IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndReceive(IAsyncResult) ser chamada. No entanto, se você iniciar várias operações assíncronas, poderá colocar seus IAsyncResult valores em uma matriz e especificar se deseja aguardar a conclusão de todas as operações ou de qualquer operação. Nesse caso, você usa a AsyncWaitHandle propriedade do IAsyncResult para identificar a operação concluída.

O objeto state associa informações de estado à operação. Por exemplo, se você chamar BeginReceive várias vezes para iniciar várias operações, poderá identificar cada operação por meio de um objeto de estado separado definido.

Você também pode usar o objeto de estado para passar informações entre threads de processo. Se um thread for iniciado, mas o retorno de chamada estiver em um thread diferente em um cenário assíncrono, o objeto de estado será marshalado e passado de volta junto com as informações do evento.

Não use a chamada BeginReceive assíncrona com transações. Se você quiser executar uma operação assíncrona transacional, chame BeginPeeke coloque a transação e o método (síncrono) Receive no manipulador de eventos criado para a operação de espiar. O manipulador de eventos pode conter funcionalidade, conforme mostrado no código C# a seguir.

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

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Object ^ state, AsyncCallback ^ callback);

public IAsyncResult BeginReceive(TimeSpan timeout, System.Messaging.Cursor cursor, object state, AsyncCallback callback);

member this.BeginReceive : TimeSpan * System.Messaging.Cursor * obj * AsyncCallback -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan, cursor As Cursor, state As Object, callback As AsyncCallback) As IAsyncResult

Parâmetros

Retornos

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

Comentários

Quando você usa essa sobrecarga, o retorno de chamada especificado no parâmetro de retorno de chamada é invocado diretamente quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expirou; o ReceiveCompleted evento não é gerado. As outras sobrecargas de BeginReceive depender desse componente para gerar o ReceiveCompleted evento.

ReceiveCompleted também será gerado se uma mensagem já existir na fila.

Para usar BeginReceive, crie um manipulador de eventos que processe os resultados da operação assíncrona e associe-o ao delegado de eventos. BeginReceive inicia uma operação de recebimento assíncrono; o MessageQueue é notificado, por meio da elevação do ReceiveCompleted evento, quando uma mensagem chega na fila. Em MessageQueue seguida, é possível acessar a mensagem chamando EndReceive(IAsyncResult) ou recuperando o resultado usando o ReceiveCompletedEventArgs.

O BeginReceive método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginReceive é assíncrono, você pode chamá-la para receber uma mensagem da fila sem bloquear o thread atual de execução. Para receber uma mensagem de forma síncrona, use o Receive método.

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona iniciada pelo método. Você pode usá-lo IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndReceive(IAsyncResult) ser chamada. No entanto, se você iniciar várias operações assíncronas, poderá colocar seus IAsyncResult valores em uma matriz e especificar se deseja aguardar a conclusão de todas as operações ou de qualquer operação. Nesse caso, use a AsyncWaitHandle propriedade do IAsyncResult para identificar a operação concluída.

O objeto state associa informações de estado à operação. Por exemplo, se você chamar BeginReceive várias vezes para iniciar várias operações, poderá identificar cada operação por meio de um objeto de estado separado definido.

Você também pode usar o objeto de estado para passar informações entre threads de processo. Se um thread for iniciado, mas o retorno de chamada estiver em um thread diferente em um cenário assíncrono, o objeto de estado será marshalado e passado de volta junto com as informações do evento.

Não use a chamada BeginReceive assíncrona com transações. Se você quiser executar uma operação assíncrona transacional, chame BeginPeeke coloque a transação e o método (síncrono) Receive no manipulador de eventos criado para a operação de espiar. O manipulador de eventos pode conter funcionalidade, conforme mostrado no código C# a seguir.

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

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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