MessageQueue.BeginReceive Método

Referência

Definição

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Inicia uma operação de recepção assíncrona informando o Enfileiramento de Mensagens para começar a receber uma mensagem e notificar o manipulador de eventos quando terminar.

Sobrecargas

BeginReceive()	Inicia uma operação de recebimento espiada assíncrona que não tem um tempo limite. A operação não será concluída até que uma mensagem fique disponível na fila.
BeginReceive(TimeSpan)	Inicia uma operação de recebimento assíncrona que tem um tempo limite especificado. A operação não será concluída até que uma mensagem fique disponível na fila ou que ocorra o tempo limite.
BeginReceive(TimeSpan, Object)	Inicia uma operação de recebimento assíncrona que tem um tempo limite e um objeto de estado especificados, que fornece informações associadas durante o tempo de vida da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.
BeginReceive(TimeSpan, Object, AsyncCallback)	Inicia uma operação de recebimento assíncrona que tem um tempo limite e um objeto de estado especificados, que fornece informações associadas durante o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Inicia uma operação de recebimento assíncrona que tem um tempo limite especificado e usa um cursor especificado e um objeto de estado especificado. O objeto de estado fornece informações associadas em todo o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.

BeginReceive()

Inicia uma operação de recebimento espiada assíncrona que não tem um tempo limite. A operação não será concluída até que uma mensagem fique disponível na fila.

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive ();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Retornos

IAsyncResult

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

Exceções

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Exemplos

O exemplo de código a seguir encadeia solicitações assíncronas. Ele pressupõe que haja 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 usa o AsyncWaitHandle em seu valor retornado. A Main rotina aguarda a conclusão de todas as operações assíncronas 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 já existir uma mensagem na fila.

Para usar BeginReceive, crie um manipulador de eventos que processe os resultados da operação assíncrona e associe-o ao representante do evento. BeginReceive inicia uma operação de recebimento assíncrona; o MessageQueue é notificado, por meio do acionamento do ReceiveCompleted evento, quando uma mensagem chega na fila. Em MessageQueue seguida, o pode 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á-lo 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 que o método iniciou. Você pode usá-lo IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndReceive(IAsyncResult) que seja chamado. 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 espiada. Seu 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.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

BeginReceive(TimeSpan)

Inicia uma operação de recebimento assíncrona que tem um tempo limite especificado. A operação não será concluída até que uma mensagem fique disponível na fila ou que ocorra o tempo limite.

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

timeout: TimeSpan

Um TimeSpan que indica o intervalo de tempo para aguardar uma mensagem se tornar disponível.

Retornos

IAsyncResult

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

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido, possivelmente porque ele representa um número negativo.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Exemplos

O exemplo de código a seguir cria uma operação de recebimento assíncrona. O exemplo de código cria um manipulador de eventos, MyReceiveCompletede o anexa ao delegado do ReceiveCompleted manipulador de eventos. O exemplo de código envia uma mensagem para uma fila de mensagens local e chama 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 já existir uma mensagem na fila.

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

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).

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

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.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

BeginReceive(TimeSpan, Object)

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

timeout: TimeSpan

Um TimeSpan que indica o intervalo de tempo para aguardar uma mensagem se tornar disponível.

stateObject: Object

Um objeto de estado, especificado pelo aplicativo, que contém informações associadas à operação assíncrona.

Retornos

IAsyncResult

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

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Exemplos

O exemplo de código a seguir cria uma operação de recebimento assíncrona. O exemplo de código cria um manipulador de eventos, MyReceiveCompletede 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, chama 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 é gerado, 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 gerar 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á preservada durante todo o tempo de vida da operação. O manipulador de eventos pode detectar essas informações examinando a AsyncState propriedade do IAsyncResult associado à 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 do acionamento do ReceiveCompleted evento, quando uma mensagem chega na fila. Em MessageQueue seguida, o pode 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.

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 usar isso 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 para EndReceive(IAsyncResult) gerará 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 state 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 novamente 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. Seu 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.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

BeginReceive(TimeSpan, Object, AsyncCallback)

Inicia uma operação de recebimento assíncrona que tem um tempo limite e um objeto de estado especificados, que fornece informações associadas durante o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.

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

timeout: TimeSpan

Um TimeSpan que indica o intervalo de tempo para aguardar uma mensagem se tornar disponível.

stateObject: Object

Um objeto de estado, especificado pelo aplicativo, que contém informações associadas à operação assíncrona.

callback: AsyncCallback

O AsyncCallback que receberá a notificação da conclusão da operação assíncrona.

Retornos

IAsyncResult

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

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

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, chama BeginReceive(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 do que identifica o manipulador de AsyncCallback eventos, MyReceiveCompleted. Quando um ReceiveCompleted evento é gerado, 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 expira; o ReceiveCompleted evento não é gerado. As outras sobrecargas de BeginReceive dependem desse componente para gerar o ReceiveCompleted evento.

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

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

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.

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. Seu 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.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Inicia uma operação de recebimento assíncrona que tem um tempo limite especificado e usa um cursor especificado e um objeto de estado especificado. O objeto de estado fornece informações associadas em todo o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.

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

timeout: TimeSpan

Um TimeSpan que indica o intervalo de tempo para aguardar uma mensagem se tornar disponível.

cursor: Cursor

Um Cursor que mantém uma posição específica na fila de mensagens.

state: Object

Um objeto de estado, especificado pelo aplicativo, que contém informações associadas à operação assíncrona.

callback: AsyncCallback

O AsyncCallback que recebe a notificação de conclusão de operação assíncrona.

Retornos

IAsyncResult

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

Exceções

ArgumentNullException

O parâmetro cursor é null.

ArgumentException

O valor especificado para o parâmetro timeout não é válido.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Comentários

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

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

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 usar isso 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.

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. Seu 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.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

Acesso thread-safe

O método não é thread-safe.

MessageQueue.BeginReceive Método

Definição

Sobrecargas

BeginReceive()

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

BeginReceive(TimeSpan)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

BeginReceive(TimeSpan, Object)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

BeginReceive(TimeSpan, Object, AsyncCallback)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Acesso thread-safe

Comentários

Recursos adicionais