MessageQueue.Receive 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.

Recebe a primeira mensagem na fila, removendo-a da fila.

Sobrecargas

Receive()	Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue. Essa chamada é síncrona e bloqueia o thread atual de execução até que uma mensagem esteja disponível.
Receive(MessageQueueTransaction)	Recebe a primeira mensagem disponível na fila transacional referenciada pelo MessageQueue. Essa chamada é síncrona e bloqueia o thread atual de execução até que uma mensagem esteja disponível.
Receive(MessageQueueTransactionType)	Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue. Essa chamada é síncrona e bloqueia o thread atual de execução até que uma mensagem esteja disponível.
Receive(TimeSpan)	Recebe a primeira mensagem disponível na fila referenciada pelo MessageQueue e aguarda até que uma mensagem esteja disponível na fila ou o tempo limite expire.
Receive(TimeSpan, Cursor)	Recebe a mensagem atual na fila usando um cursor especificado. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar.
Receive(TimeSpan, MessageQueueTransaction)	Recebe a primeira mensagem disponível na fila transacional referenciada pelo MessageQueue e aguarda até que uma mensagem esteja disponível na fila ou o tempo limite expire.
Receive(TimeSpan, MessageQueueTransactionType)	Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue. Esta chamada é síncrona e aguarda até que uma mensagem esteja disponível na fila ou que o tempo limite expire.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Recebe a mensagem atual na fila usando um cursor especificado. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Recebe a mensagem atual na fila usando um cursor especificado. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar.

Receive()

Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue. Essa chamada é síncrona e bloqueia o thread atual de execução até que uma mensagem esteja disponível.

public:
 System::Messaging::Message ^ Receive();

public System.Messaging.Message Receive ();

member this.Receive : unit -> System.Messaging.Message

Public Function Receive () As Message

Retornos

Message

Uma Message que faz referência à primeira mensagem disponível na fila.

Exceções

MessageQueueException

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

Exemplos

O exemplo de código a seguir recebe uma mensagem de uma fila e gera informações sobre essa mensagem para a tela.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// sends to a queue and receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends an Order to a queue.
   //*************************************************
   void SendMessage()
   {
      // Create a new order and set values.
      Order^ sentOrder = gcnew Order;
      sentOrder->orderId = 3;
      sentOrder->orderTime = DateTime::Now;

      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Send the Order to the queue.
      myQueue->Send( sentOrder );
      return;
   }

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example sends and receives a message from
// a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    // This class represents an object the following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            
            // Create a new order and set values.
            Order sentOrder = new Order();
            sentOrder.orderId = 3;
            sentOrder.orderTime = DateTime.Now;

            // Connect to a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

    ' This class represents an object the following example 
    ' sends to a queue and receives from a queue.
    Public Class Order
        Public orderId As Integer
        Public orderTime As DateTime
    End Class


   
    Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example sends and receives a message from
        ' a qeue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Sends an Order to a queue.
        '

        Public Sub SendMessage()

            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Send the Order to the queue.
            myQueue.Send(sentOrder)

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate the body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                Dim myMessage As Message = myQueue.Receive()
                Dim myOrder As Order = CType(myMessage.Body, Order)

                ' Display message information.
                Console.WriteLine(("Order ID: " + _
                    myOrder.orderId.ToString()))
                Console.WriteLine(("Sent: " + _
                    myOrder.orderTime.ToString()))

            Catch m As MessageQueueException
                ' Handle Message Queuing exceptions.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)


                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Comentários

Use essa sobrecarga para receber uma mensagem de uma fila ou aguardar até que haja mensagens na fila.

O Receive método permite a leitura síncrona de uma mensagem, removendo-a da fila. Chamadas subsequentes para Receive retornarão as mensagens que seguem na fila ou novas mensagens de prioridade mais alta.

Use uma chamada para Receive quando for aceitável que o thread atual seja bloqueado enquanto aguarda a chegada de uma mensagem na fila. Como essa sobrecarga do Receive método especifica um tempo limite infinito, o aplicativo pode aguardar indefinidamente. Se o processamento do aplicativo deve continuar sem aguardar a mensagem, considere usar o método assíncrono , BeginReceive.

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

Receive(MessageQueueTransaction)

Recebe a primeira mensagem disponível na fila transacional referenciada pelo MessageQueue. Essa chamada é síncrona e bloqueia o thread atual de execução até que uma mensagem esteja disponível.

public:
 System::Messaging::Message ^ Receive(System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive (System.Messaging.MessageQueueTransaction transaction);

member this.Receive : System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (transaction As MessageQueueTransaction) As Message

Parâmetros

transaction: MessageQueueTransaction

O objeto MessageQueueTransaction.

Retornos

Message

Uma Message que faz referência à primeira mensagem disponível na fila.

Exceções

MessageQueueException

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

- ou -

A fila é não transacional.

Exemplos

O exemplo de código a seguir se conecta a uma fila transacional no computador local e envia uma mensagem para a fila. Em seguida, ele recebe a mensagem que contém um pedido. Se encontrar uma fila não transacional, ela gerará e a exceção e reverterá a transação.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends a message to a queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }


   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessageTransactional()
   {
      // Connect to a transactional queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         Message^ myMessage = myQueue->Receive( myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }

         // Else catch other sources of a MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
// 
// This example sends and receives a message from
// a transactional queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessageTransactional();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //
        // This example sends and receives a message from
        // a transactional queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessageTransactional();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();

            return;
        }

        //**************************************************
        // Sends a message to a queue.
        //**************************************************
        
        public void SendMessageTransactional()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessageTransactional()
        {
            // Connect to a transactional queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                Message myMessage =	myQueue.Receive(myTransaction);
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }
                
                // Else catch other sources of a MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        ' 
        ' This example sends and receives a message from
        ' a transactional queue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue

            ' Send a message to a queue.
            myNewQueue.SendMessageTransactional()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional()

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessageTransactional()

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

            End If

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessageTransactional()

            ' Connect to a transactional queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                Dim myMessage As Message = _
                    myQueue.Receive(myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                End If

                ' Else catch other sources of a MessageQueueException.


                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as 
                ' InvalidOperationException, thrown when the formatter
                ' cannot deserialize the message.

            End Try

            Return

        End Sub

End Class

Comentários

Use essa sobrecarga para receber uma mensagem de uma fila transacional usando o contexto de transação interna definido pelo transaction parâmetro ou aguarde até que haja mensagens na fila.

O Receive método permite a leitura síncrona de uma mensagem, removendo-a da fila. Chamadas subsequentes para Receive retornarão as mensagens que seguem na fila.

Como esse método é chamado em uma fila transacional, a mensagem recebida será retornada para a fila se a transação for anulada. A mensagem não será removida permanentemente da fila até que a transação seja confirmada.

Para ler a primeira mensagem em uma fila sem removê-la da fila, use o Peek método . O Peek método sempre retorna a primeira mensagem na fila, portanto, chamadas subsequentes para o método retornam a mesma mensagem, a menos que uma mensagem de prioridade mais alta chegue à fila. Não há nenhum contexto de transação associado a uma mensagem retornada por uma chamada para Peek. Como Peek não remove nenhuma mensagem na fila, não haveria nada para reverter por uma chamada para Abort.

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

Receive(MessageQueueTransactionType)

Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue. Essa chamada é síncrona e bloqueia o thread atual de execução até que uma mensagem esteja disponível.

public:
 System::Messaging::Message ^ Receive(System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive (System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (transactionType As MessageQueueTransactionType) As Message

Parâmetros

transactionType: MessageQueueTransactionType

Um dos valores de MessageQueueTransactionType, que descreve o tipo de contexto de transação associado à mensagem.

Retornos

Message

Uma Message que faz referência à primeira mensagem disponível na fila.

Exceções

MessageQueueException

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

InvalidEnumArgumentException

O parâmetro transactionType não é um dos membros do MessageQueueTransactionType.

Exemplos

O exemplo de código a seguir demonstra o uso de Receive(MessageQueueTransactionType).


// Connect to a transactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

// Simulate doing other work so the message has time to arrive.
System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));

// Set the formatter to indicate the message body contains a String.
queue->Formatter = gcnew XmlMessageFormatter(
    gcnew array<Type^>{String::typeid});

// Receive the message from the queue.  Because the Id of the message
// , it might not be the message just sent.
msg = queue->Receive(MessageQueueTransactionType::Single);

queue->Close();


// Connect to a transactional queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

// Simulate doing other work so the message has time to arrive.
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

// Set the formatter to indicate the message body contains a String.
queue.Formatter = new XmlMessageFormatter(new Type[]
    {typeof(String)});

// Receive the message from the queue.  Because the Id of the message
// , it might not be the message just sent.
msg = queue.Receive(MessageQueueTransactionType.Single);

Comentários

Use essa sobrecarga para receber uma mensagem de uma fila usando um contexto de transação definido pelo transactionType parâmetro ou aguarde até que haja mensagens na fila.

Especifique Automatic para o transactionType parâmetro se já houver um contexto de transação externo anexado ao thread que você deseja usar para receber a mensagem. Especifique Single se deseja receber a mensagem como uma única transação interna. Você pode especificar None se deseja receber uma mensagem de uma fila transacional fora de um contexto de transação.

O Receive método permite a leitura síncrona de uma mensagem, removendo-a da fila. Chamadas subsequentes para Receive retornarão as mensagens que seguem na fila.

Se esse método for chamado para receber uma mensagem de uma fila transacional, a mensagem recebida será retornada para a fila se a transação for anulada. A mensagem não será removida permanentemente da fila até que a transação seja confirmada.

Para ler a primeira mensagem em uma fila sem removê-la da fila, use o Peek método . O Peek método sempre retorna a primeira mensagem na fila, portanto, chamadas subsequentes para o método retornam a mesma mensagem, a menos que uma mensagem de prioridade mais alta chegue na fila. Não há nenhum contexto de transação associado a uma mensagem retornada por uma chamada para Peek. Como Peek não remove nenhuma mensagem na fila, não haveria nada a ser revertido por uma chamada para Abort.

Use uma chamada para Receive quando for aceitável que o thread atual seja bloqueado enquanto aguarda a chegada de uma mensagem na fila. Como essa sobrecarga do Receive método especifica um tempo limite infinito, o aplicativo pode esperar indefinidamente. Se o processamento do aplicativo deve continuar sem aguardar a mensagem, considere usar o método assíncrono , BeginReceive.

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

Receive(TimeSpan)

Recebe a primeira mensagem disponível na fila referenciada pelo MessageQueue e aguarda até que uma mensagem esteja disponível na fila ou o tempo limite expire.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout);

public System.Messaging.Message Receive (TimeSpan timeout);

member this.Receive : TimeSpan -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan) As Message

Parâmetros

timeout: TimeSpan

Um TimeSpan que indica o tempo de espera até que uma nova mensagem esteja disponível para inspeção.

Retornos

Message

Uma Message que faz referência à primeira mensagem disponível na fila.

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido, possivelmente timeout é menor que Zero ou maior que InfiniteTimeout.

MessageQueueException

Uma mensagem não chegou à fila antes do tempo limite expirar.

- ou -

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

Exemplos

O exemplo de código a seguir recebe uma mensagem de uma fila e gera informações sobre essa mensagem para a tela. O exemplo pausa a execução por até cinco segundos enquanto aguarda a chegada de uma mensagem na fila.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         // Wait 5 seconds for a message to arrive.
         Message^ myMessage = myQueue->Receive( TimeSpan(0,0,5) );
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle no message arriving in the queue.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( "No message arrived in queue." );
         }

         // Handle other sources of a MessageQueueException.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example receives a message from a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    // This class represents an object the following example
    // receives from a queue.

    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example receives a message from a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************

        public void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                // Wait 5 seconds for a message to arrive.
                Message myMessage =	myQueue.Receive(new
                    TimeSpan(0,0,5));
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }

            catch (MessageQueueException e)
            {
                // Handle no message arriving in the queue.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine("No message arrived in queue.");
                }			

                // Handle other sources of a MessageQueueException.
            }
            
            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

' This class represents an object the following example 
' receives from a queue.
Public Class Order
        Public orderId As Integer
        Public orderTime As DateTime
End Class


   
Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example receives a message from a queue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                ' Wait 5 seconds for a message to arrive.
                Dim myMessage As Message = myQueue.Receive(New _
                    TimeSpan(0, 0, 5))
                Dim myOrder As Order = CType(myMessage.Body, Order)

                ' Display message information.
                Console.WriteLine(("Order ID: " + _
                    myOrder.orderId.ToString()))
                Console.WriteLine(("Sent: " + _
                    myOrder.orderTime.ToString()))

            Catch e As MessageQueueException
                ' Handle no message arriving in the queue.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    Console.WriteLine("No message arrived in queue.")

                End If

                ' Handle other sources of a MessageQueueException.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)

                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Comentários

Use essa sobrecarga para receber uma mensagem e retorná-la em um período de tempo especificado se não houver mensagens na fila.

Use uma chamada para Receive quando for aceitável que o thread atual seja bloqueado enquanto aguarda a chegada de uma mensagem na fila. O thread será bloqueado pelo período de tempo determinado ou indefinidamente se você tiver especificado o valor InfiniteTimeout para o timeout parâmetro . Se o processamento do aplicativo deve continuar sem esperar por uma mensagem, considere usar o método assíncrono , BeginReceive.

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

Receive(TimeSpan, Cursor)

Recebe a mensagem atual na fila usando um cursor especificado. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor);

member this.Receive : TimeSpan * System.Messaging.Cursor -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor) As Message

Parâmetros

timeout: TimeSpan

Um TimeSpan que indica o tempo de espera até que uma nova mensagem esteja disponível para inspeção.

cursor: Cursor

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

Retornos

Message

Uma Message que faz referência à primeira mensagem disponível na fila.

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido, possivelmente timeout é menor que Zero ou maior que InfiniteTimeout.

MessageQueueException

Uma mensagem não chegou à fila antes do tempo limite expirar.

- ou -

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

Use essa sobrecarga para receber uma mensagem e retorná-la em um período de tempo especificado se não houver mensagens na fila.

Aplica-se a

Receive(TimeSpan, MessageQueueTransaction)

Recebe a primeira mensagem disponível na fila transacional referenciada pelo MessageQueue e aguarda até que uma mensagem esteja disponível na fila ou o tempo limite expire.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.MessageQueueTransaction transaction);

member this.Receive : TimeSpan * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, transaction As MessageQueueTransaction) As Message

Parâmetros

timeout: TimeSpan

Um TimeSpan que indica o tempo de espera até que uma nova mensagem esteja disponível para inspeção.

transaction: MessageQueueTransaction

O objeto MessageQueueTransaction.

Retornos

Message

Uma Message que faz referência à primeira mensagem disponível na fila.

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido, possivelmente timeout é menor que Zero ou maior que InfiniteTimeout.

MessageQueueException

Uma mensagem não chegou à fila antes do tempo limite expirar.

- ou -

A fila é não transacional.

- ou -

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

Exemplos

O exemplo de código a seguir demonstra o uso desse método.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends a message to a transactional queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }

   //*************************************************
   // Receives a message from the transactional queue.
   //*************************************************
   void ReceiveMessageTransactional()
   {
      // Connect to a transactional queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         // Wait five seconds for a message to arrive. 
         Message^ myMessage = myQueue->Receive( TimeSpan(0,0,5), myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }
         // Handle no message arriving in the queue.
         else

         // Handle no message arriving in the queue.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( "No message in queue." );
         }

         // Else catch other sources of MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
// 
// This example sends and receives a message from
// a transactional queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessageTransactional();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //
        // This example sends and receives a message from
        // a transactional queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessageTransactional();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();

            return;
        }

        //**************************************************
        // Sends a message to a transactional queue.
        //**************************************************
        
        public void SendMessageTransactional()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

        //**************************************************
        // Receives a message from the transactional queue.
        //**************************************************
        
        public  void ReceiveMessageTransactional()
        {
            // Connect to a transactional queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                // Wait five seconds for a message to arrive.
                Message myMessage =	myQueue.Receive(new
                    TimeSpan(0,0,5), myTransaction);
                
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }

                    // Handle no message arriving in the queue.
                else if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine("No message in queue.");
                }
                
                // Else catch other sources of MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}

Imports System.Messaging

Namespace MyProj


   
    Public Class MyNewQueue


        '**************************************************
        ' Provides an entry point into the application.
        ' 
        ' This example sends and receives a message from
        ' a transactional queue.
        '**************************************************

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue

            ' Send a message to a queue.
            myNewQueue.SendMessageTransactional()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional()

            Return

        End Sub


        '**************************************************
        ' Sends a message to a transactional queue.
        '**************************************************

        Public Sub SendMessageTransactional()

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

            End If

            Return

        End Sub


        '**************************************************
        ' Receives a message from the transactional queue.
        '**************************************************

        Public Sub ReceiveMessageTransactional()

            ' Connect to a transactional queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                ' Wait five seconds for a message to arrive. 
                Dim myMessage As Message = myQueue.Receive(New _
                    TimeSpan(0, 0, 5), myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                Else
                    ' Handle no message arriving in the queue.
                    If e.MessageQueueErrorCode = _
                        MessageQueueErrorCode.IOTimeout Then

                        Console.WriteLine("No message in queue.")

                    End If
                End If

                ' Else catch other sources of a MessageQueueException.

                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as InvalidOperationException,
                ' thrown when the formatter cannot deserialize the message.

            End Try

            Return

        End Sub

    End Class
End Namespace 'MyProj

Comentários

Use essa sobrecarga para receber uma mensagem de uma fila transacional usando o contexto de transação interna definido pelo transaction parâmetro e retorne dentro de um período de tempo especificado se não houver mensagens na fila.

O Receive método permite a leitura síncrona de uma mensagem, removendo-a da fila. Chamadas subsequentes para Receive retornarão as mensagens que seguem na fila.

Para ler a primeira mensagem em uma fila sem removê-la da fila, use o Peek método . O Peek método sempre retorna a primeira mensagem na fila, portanto, chamadas subsequentes para o método retornam a mesma mensagem, a menos que uma mensagem de prioridade mais alta chegue na fila. Não há nenhum contexto de transação associado a uma mensagem retornada por uma chamada para Peek. Como Peek não remove nenhuma mensagem na fila, não haveria nada a ser revertido por uma chamada para Abort.

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

Receive(TimeSpan, MessageQueueTransactionType)

Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue. Esta chamada é síncrona e aguarda até que uma mensagem esteja disponível na fila ou que o tempo limite expire.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : TimeSpan * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, transactionType As MessageQueueTransactionType) As Message

Parâmetros

timeout: TimeSpan

Um TimeSpan que indica o tempo de espera até que uma nova mensagem esteja disponível para inspeção.

transactionType: MessageQueueTransactionType

Um dos valores de MessageQueueTransactionType, que descreve o tipo de contexto de transação associado à mensagem.

Retornos

Message

Uma Message que faz referência à primeira mensagem disponível na fila.

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido, possivelmente timeout é menor que Zero ou maior que InfiniteTimeout.

InvalidEnumArgumentException

O parâmetro transactionType não é um dos membros do MessageQueueTransactionType.

MessageQueueException

Uma mensagem não chegou à fila antes do tempo limite expirar.

- ou -

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

Exemplos

O exemplo de código a seguir demonstra o uso desse método.


// Connect to a transactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

// Set the formatter to indicate the message body contains a String.
queue->Formatter = gcnew XmlMessageFormatter(
    gcnew array<Type^>{String::typeid});

// Receive the message from the queue. Because the Id of the message
// is not specified, it might not be the message just sent.
msg = queue->Receive(TimeSpan::FromSeconds(10.0),
    MessageQueueTransactionType::Single);

queue->Close();


// Connect to a transactional queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

// Set the formatter to indicate the message body contains a String.
queue.Formatter = new XmlMessageFormatter(new Type[]
    {typeof(String)});

// Receive the message from the queue. Because the Id of the message
// is not specified, it might not be the message just sent.
msg = queue.Receive(TimeSpan.FromSeconds(10.0),
    MessageQueueTransactionType.Single);

Comentários

Use essa sobrecarga para receber uma mensagem de uma fila usando um contexto de transação definido pelo transactionType parâmetro e retorne em um período de tempo especificado se não houver mensagens na fila.

O Receive método permite a leitura síncrona de uma mensagem, removendo-a da fila. Chamadas subsequentes para Receive retornarão as mensagens que seguem na fila.

Para ler a primeira mensagem em uma fila sem removê-la da fila, use o Peek método . O Peek método sempre retorna a primeira mensagem na fila, portanto, chamadas subsequentes para o método retornam a mesma mensagem, a menos que uma mensagem de prioridade mais alta chegue na fila. Não há nenhum contexto de transação associado a uma mensagem retornada por uma chamada para Peek. Como Peek não remove nenhuma mensagem na fila, não haveria nada a ser revertido por uma chamada para Abort.

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

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Recebe a mensagem atual na fila usando um cursor especificado. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransaction transaction);

member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor, transaction As MessageQueueTransaction) As Message

Parâmetros

timeout: TimeSpan

Um TimeSpan que indica o tempo de espera até que uma nova mensagem esteja disponível para inspeção.

cursor: Cursor

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

transaction: MessageQueueTransaction

O objeto MessageQueueTransaction.

Retornos

Message

Um Message que faz referência a uma mensagem na fila.

Exceções

ArgumentNullException

O parâmetro cursor é null.

- ou -

O parâmetro transaction é null.

ArgumentException

O valor especificado para o parâmetro timeout não é válido. Provavelmente timeout é menor que Zero ou maior que InfiniteTimeout.

MessageQueueException

Uma mensagem não chegou à fila antes do tempo limite expirar.

- ou -

A fila é não transacional.

- ou -

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

Comentários

O Receive método permite a leitura síncrona de uma mensagem, removendo-a da fila. Chamadas subsequentes para Receive retornar as mensagens que seguem na fila.

Para ler uma mensagem em uma fila sem removê-la da fila, use o Peek método . Não há nenhum contexto de transação associado a uma mensagem retornada por uma chamada para Peek. Como Peek não remove nenhuma mensagem na fila, não há nada a ser revertido por uma chamada para Abort.

Use uma chamada para Receive quando for aceitável que o thread atual seja bloqueado enquanto aguarda a chegada de uma mensagem na fila. O thread é bloqueado pelo período de tempo determinado ou indefinidamente se você especificou o valor InfiniteTimeout para o timeout parâmetro . Se o processamento do aplicativo deve continuar sem esperar por uma mensagem, considere usar o método assíncrono , BeginReceive.

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

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Recebe a mensagem atual na fila usando um cursor especificado. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor, transactionType As MessageQueueTransactionType) As Message

Parâmetros

timeout: TimeSpan

Um TimeSpan que indica o tempo de espera até que uma nova mensagem esteja disponível para inspeção.

cursor: Cursor

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

transactionType: MessageQueueTransactionType

Um dos valores de MessageQueueTransactionType que descreve o tipo de contexto de transação associado à mensagem.

Retornos

Message

Um Message que faz referência a uma mensagem na fila.

Exceções

ArgumentNullException

O parâmetro cursor é null.

ArgumentException

O valor especificado para o parâmetro timeout não é válido. Provavelmente timeout é menor que Zero ou maior que InfiniteTimeout.

InvalidEnumArgumentException

O parâmetro transactionType não é um dos membros do MessageQueueTransactionType.

MessageQueueException

Uma mensagem não chegou à fila antes do tempo limite expirar.

- ou -

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

Comentários

O Receive método permite a leitura síncrona de uma mensagem, removendo-a da fila. Chamadas subsequentes para Receive retornar as mensagens que seguem na fila.

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.

Partilhar via

MessageQueue.Receive Método

Definição

Sobrecargas

Receive()

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Receive(MessageQueueTransaction)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Receive(MessageQueueTransactionType)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Receive(TimeSpan)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Receive(TimeSpan, Cursor)

Parâmetros

Retornos

Exceções

Aplica-se a

Receive(TimeSpan, MessageQueueTransaction)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Receive(TimeSpan, MessageQueueTransactionType)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Acesso thread-safe

Recursos adicionais