MessageQueue.BeginReceive Método

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Exemplos

O exemplo de código seguinte encadeia pedidos assíncronos. Assume que existe uma fila no computador local chamada "myQueue". A Main função inicia a operação assíncrona que é gerida pela MyReceiveCompleted rotina. MyReceiveCompleted processa a mensagem atual e inicia uma nova operação de receção assíncrona.

#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 seguinte coloca em fila pedidos assíncronos. A chamada para BeginReceive usa o AsyncWaitHandle no seu valor de retorno. A Main rotina espera 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

Observações

No processamento assíncrono, é usado BeginReceive para gerar o ReceiveCompleted evento quando uma mensagem é removida da fila.

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

Para usar BeginReceive, crie um gestor de eventos que processe os resultados da operação assíncrona e associe-o ao seu delegado de eventos. BeginReceive inicia uma operação de receção assíncrona; é MessageQueue notificado, através do levantamento do ReceiveCompleted evento, quando uma mensagem chega à fila. Podem MessageQueue então aceder à mensagem chamando EndReceive(IAsyncResult).

O BeginReceive método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona que o método iniciou. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndReceive(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, usa a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

Se CanRead for false, o evento de conclusão é levantado, mas será lançada uma exceção ao chamar EndReceive(IAsyncResult).

Não use a chamada BeginReceive assíncrona com transações. Se quiser realizar uma operação transacional assíncrona, chame BeginPeek, e coloque a transação e o método (síncrono) Receive dentro do gestor de eventos que criou para a operação peek. O seu gestor de eventos pode conter funcionalidades, conforme mostrado no código C# seguinte.

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

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver 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

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Exemplos

O exemplo de código seguinte cria uma operação de receção assíncrona. O exemplo de código cria um gestor de eventos, MyReceiveCompleted, e anexa-o ao ReceiveCompleted delegado do gestor de eventos. O exemplo de código envia uma mensagem para uma fila de mensagens local, depois chama BeginReceive(TimeSpan), passando com um valor de time-out de dez segundos. Quando um ReceiveCompleted evento é levantado, o gestor de eventos recebe a mensagem e escreve o corpo da mensagem no ecrã.

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

Observações

No processamento assíncrono, é usado BeginReceive para levantar o ReceiveCompleted evento quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira.

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

Para usar BeginReceive, crie um gestor de eventos que processe os resultados da operação assíncrona e associe-o ao seu delegado de eventos. BeginReceive inicia uma operação de receção assíncrona; é MessageQueue notificado, através do levantamento do ReceiveCompleted evento, quando uma mensagem chega à fila. Podem MessageQueue então aceder à mensagem chamando EndReceive(IAsyncResult) ou recuperando o resultado usando o ReceiveCompletedEventArgs.

O BeginReceive método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

Se CanRead for false, o evento de conclusão é levantado, mas será lançada uma exceção ao chamar EndReceive(IAsyncResult).

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona que o método iniciou. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndReceive(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, usa a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

Esta sobrecarga especifica um time-out. Se o intervalo especificado pelo timeout parâmetro expirar, este componente eleva o ReceiveCompleted evento. Como não existe mensagem, uma chamada subsequente para EndReceive(IAsyncResult) lançará uma exceção.

Não use a chamada BeginReceive assíncrona com transações. Se quiser realizar uma operação transacional assíncrona, chame BeginPeek, e coloque a transação e o método (síncrono) Receive dentro do gestor de eventos que criou para a operação peek. O seu gestor de eventos pode conter funcionalidades, conforme mostrado no código C# seguinte.

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

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver 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

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Exemplos

O exemplo de código seguinte cria uma operação de receção assíncrona. O exemplo de código cria um gestor de eventos, MyReceiveCompleted, e anexa-o ao ReceiveCompleted delegado do gestor de eventos. O exemplo de código envia uma mensagem para uma fila de mensagens local, depois chama BeginReceive(TimeSpan, Object), passando um valor de time-out de dez segundos e um inteiro único que identifica essa mensagem em particular. Quando um ReceiveCompleted evento é gerado, o gestor de eventos recebe a mensagem e escreve o corpo da mensagem e o identificador inteiro da mensagem no ecrã.

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

Observações

No processamento assíncrono, é usado BeginReceive para levantar o ReceiveCompleted evento quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira.

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

Utilize esta sobrecarga para associar informações à operação que serão preservadas ao longo de toda a vida útil da operação. O gestor de eventos pode detetar esta informação analisando a AsyncState propriedade de o IAsyncResult que está associada à operação.

Para usar BeginReceive, crie um gestor de eventos que processe os resultados da operação assíncrona e associe-o ao seu delegado de eventos. BeginReceive inicia uma operação de receção assíncrona; é MessageQueue notificado, através do levantamento do ReceiveCompleted evento, quando uma mensagem chega à fila. Podem MessageQueue então aceder à mensagem chamando EndReceive(IAsyncResult) ou recuperando o resultado usando o ReceiveCompletedEventArgs.

O BeginReceive método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona que o método iniciou. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndReceive(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, usa a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

Esta sobrecarga especifica um time-out e um objeto de estado. Se o intervalo especificado pelo timeout parâmetro expirar, este componente eleva o ReceiveCompleted evento. Como não existe mensagem, uma chamada subsequente para EndReceive(IAsyncResult) lançará uma exceção.

O objeto de estado associa a informação de estado à operação. Por exemplo, se chamar BeginReceive várias vezes para iniciar várias operações, pode identificar cada operação através de um objeto de estado separado que define.

Também podes usar o objeto estado para passar informação entre threads de processo. Se um thread for iniciado mas o callback estiver num thread diferente num cenário assíncrono, o objeto de estado é marshalizado e repassado juntamente com a informação do evento.

Não use a chamada BeginReceive assíncrona com transações. Se quiser realizar uma operação transacional assíncrona, chame BeginPeek, e coloque a transação e o método (síncrono) Receive dentro do gestor de eventos que criou para a operação peek. O seu gestor de eventos pode conter funcionalidades, conforme mostrado no código C# seguinte.

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

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver 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

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Exemplos

O exemplo de código seguinte cria uma operação de receção assíncrona. O exemplo de código envia uma mensagem para uma fila de mensagens local, depois chama BeginReceive(TimeSpan, Object, AsyncCallback), passando em: um valor de time-out de dez segundos; um inteiro único que identifica essa mensagem em particular; e uma nova instância disso AsyncCallback que identifica o gestor de eventos, MyReceiveCompleted. Quando um ReceiveCompleted evento é gerado, o gestor de eventos recebe a mensagem e escreve o corpo da mensagem e o identificador inteiro da mensagem no ecrã.

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

Observações

Quando se utiliza esta sobrecarga, o callback especificado no parâmetro de callback é invocado diretamente quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira; o ReceiveCompleted evento não é levantado. As outras sobrecargas dependem BeginReceive deste componente para elevar o ReceiveCompleted evento.

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

Para usar BeginReceive, crie um gestor de eventos que processe os resultados da operação assíncrona e associe-o ao seu delegado de eventos. BeginReceive inicia uma operação de receção assíncrona; é MessageQueue notificado, através do levantamento do ReceiveCompleted evento, quando uma mensagem chega à fila. Podem MessageQueue então aceder à mensagem chamando EndReceive(IAsyncResult) ou recuperando o resultado usando o ReceiveCompletedEventArgs.

O BeginReceive método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona que o método iniciou. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndReceive(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, usa a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

O objeto de estado associa a informação de estado à operação. Por exemplo, se chamar BeginReceive várias vezes para iniciar várias operações, pode identificar cada operação através de um objeto de estado separado que define.

Também podes usar o objeto estado para passar informação entre threads de processo. Se um thread for iniciado mas o callback estiver num thread diferente num cenário assíncrono, o objeto de estado é marshalizado e repassado juntamente com a informação do evento.

Não use a chamada BeginReceive assíncrona com transações. Se quiser realizar uma operação transacional assíncrona, chame BeginPeek, e coloque a transação e o método (síncrono) Receive dentro do gestor de eventos que criou para a operação peek. O seu gestor de eventos pode conter funcionalidades, conforme mostrado no código C# seguinte.

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

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver 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

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Observações

Quando se utiliza esta sobrecarga, o callback especificado no parâmetro de callback é invocado diretamente quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira; o ReceiveCompleted evento não é levantado. As outras sobrecargas dependem BeginReceive deste componente para elevar o ReceiveCompleted evento.

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

Para usar BeginReceive, crie um gestor de eventos que processe os resultados da operação assíncrona e associe-o ao seu delegado de eventos. BeginReceive inicia uma operação de receção assíncrona; é MessageQueue notificado, através do levantamento do ReceiveCompleted evento, quando uma mensagem chega à fila. Podem MessageQueue então aceder à mensagem chamando EndReceive(IAsyncResult) ou recuperando o resultado usando o ReceiveCompletedEventArgs.

O BeginReceive método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

O IAsyncResult que BeginReceive retorna identifica a operação assíncrona que o método iniciou. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndReceive(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, use a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

O objeto de estado associa a informação de estado à operação. Por exemplo, se chamar BeginReceive várias vezes para iniciar várias operações, pode identificar cada operação através de um objeto de estado separado que define.

Também podes usar o objeto estado para passar informação entre threads de processo. Se um thread for iniciado mas o callback estiver num thread diferente num cenário assíncrono, o objeto de estado é marshalizado e repassado juntamente com a informação do evento.

Não use a chamada BeginReceive assíncrona com transações. Se quiser realizar uma operação transacional assíncrona, chame BeginPeek, e coloque a transação e o método (síncrono) Receive dentro do gestor de eventos que criou para a operação peek. O seu gestor de eventos pode conter funcionalidades, conforme mostrado no código C# seguinte.

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

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver também

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