MessageQueue.Receive MessageQueue.Receive MessageQueue.Receive MessageQueue.Receive Method

Definición

Recibe el primer mensaje de la cola y lo quita de esta.Receives the first message in the queue, removing it from the queue.

Sobrecargas

Receive() Receive() Receive() Receive()

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction)

Recibe el primer mensaje disponible en la cola transaccional a la que hace referencia MessageQueue.Receives the first message available in the transactional queue referenced by the MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType)

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan)

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue y espera hasta que haya un mensaje en la cola o hasta que expire el tiempo de espera.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor)

Recibe el mensaje actual en la cola, utilizando un cursor especificado.Receives the current message in the queue, using a specified cursor. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction)

Recibe el primer mensaje disponible en la cola transaccional a la que hace referencia MessageQueue y espera hasta que haya un mensaje en la cola o hasta que expire el tiempo de espera.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType)

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. La llamada es sincrónica y espera hasta que haya un mensaje disponible en la cola o hasta que expira el tiempo de espera.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction)

Recibe el mensaje actual en la cola, utilizando un cursor especificado.Receives the current message in the queue, using a specified cursor. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Recibe el mensaje actual en la cola, utilizando un cursor especificado.Receives the current message in the queue, using a specified cursor. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive() Receive() Receive() Receive()

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.This call is synchronous, and blocks the current thread of execution until a message is available.

public:
 System::Messaging::Message ^ Receive();
public System.Messaging.Message Receive ();
member this.Receive : unit -> System.Messaging.Message
Public Function Receive () As Message

Devoluciones

Message que hace referencia al primer mensaje disponible en la cola.A Message that references the first message available in the queue.

Excepciones

Error al obtener acceso a un método de Message Queuing.An error occurred when accessing a Message Queuing method.

Ejemplos

El ejemplo de código siguiente recibe un mensaje de una cola y envía la información sobre ese mensaje a la pantalla.The following code example receives a message from a queue and outputs information about that message to the screen.

#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
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 'Order


   
    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 'Main


        '
        ' 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 'SendMessage


        '
        ' 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 'ReceiveMessage

End Class 'MyNewQueue

Comentarios

Utilice esta sobrecarga para recibir un mensaje de una cola o espere a que hay mensajes en la cola.Use this overload to receive a message from a queue, or wait until there are messages in the queue.

El Receive método permite la lectura sincrónica de un mensaje, y lo quita de la cola.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Las llamadas subsiguientes a Receive devolverá los mensajes que siguen en la cola o nuevo, los mensajes de prioridad más alto.Subsequent calls to Receive will return the messages that follow in the queue, or new, higher priority messages.

Para leer el primer mensaje en una cola sin quitarlo de la cola, utilice el Peek método.To read the first message in a queue without removing it from the queue, use the Peek method. El Peek método siempre devuelve el primer mensaje en la cola, por lo que las llamadas subsiguientes al método devuelven el mismo mensaje a menos que llegue un mensaje de mayor prioridad en la cola.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue.

Usar una llamada a Receive cuando sea aceptable para el subproceso actual se bloquee mientras espera un mensaje llegue a la cola.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Dado que esta sobrecarga de la Receive método especifica un tiempo de espera infinito, la aplicación podría esperar indefinidamente.Because this overload of the Receive method specifies an infinite time-out, the application might wait indefinitely. Si el procesamiento de la aplicación debe continuar sin esperar a que el mensaje, considere la posibilidad de utilizar el método asincrónico, BeginReceive.If the application processing should continue without waiting for the message, consider using the asynchronous method, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en los distintos modos de grupo de trabajo.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabajoWorkgroup mode DisponibleAvailable
Equipo localLocal computer Yes
Equipo local y el nombre de formato directoLocal computer and direct format name Yes
Equipo remotoRemote computer NoNo
Equipo remoto y el nombre de formato directoRemote computer and direct format name Yes
Consulte también:

Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction)

Recibe el primer mensaje disponible en la cola transaccional a la que hace referencia MessageQueue.Receives the first message available in the transactional queue referenced by the MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.This call is synchronous, and blocks the current thread of execution until a message is available.

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

Devoluciones

Message que hace referencia al primer mensaje disponible en la cola.A Message that references the first message available in the queue.

Excepciones

Error al obtener acceso a un método de Message Queuing.An error occurred when accessing a Message Queuing method.

O bien-or-

La cola no es transaccional.The queue is non-transactional.

Ejemplos

El siguiente ejemplo de código se conecta a una cola transaccional en el equipo local y envía un mensaje a la cola.The following code example connects to a transactional queue on the local computer and sends a message to the queue. A continuación, recibe el mensaje que contiene un pedido.It then receives the message that contains an order. Si se encuentra una cola no transaccional, producirá excepciones y se deshace la transacción.If it encounters a non-transactional queue, it will throw and exception and rollback the transaction.

#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
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 'Main


        '
        ' 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 'SendMessageTransactional


        '
        ' 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 'ReceiveMessageTransactional

End Class 'MyNewQueue

Comentarios

Utilice esta sobrecarga para recibir un mensaje de una cola transaccional utilizando el contexto de transacción interna definido por el transaction parámetro o espere hasta que haya mensajes en la cola.Use this overload to receive a message from a transactional queue using the internal transaction context defined by the transaction parameter, or wait until there are messages in the queue.

El Receive método permite la lectura sincrónica de un mensaje, y lo quita de la cola.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Las llamadas subsiguientes a Receive devolverá los mensajes que siguen en la cola.Subsequent calls to Receive will return the messages that follow in the queue.

Dado que este método se llama en una cola transaccional, el mensaje recibido se devolvería a la cola si se anula la transacción.Because this method is called on a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.The message is not permanently removed from the queue until the transaction is committed.

Para leer el primer mensaje en una cola sin quitarlo de la cola, utilice el Peek método.To read the first message in a queue without removing it from the queue, use the Peek method. El Peek método siempre devuelve el primer mensaje en la cola, por lo que las llamadas subsiguientes al método devuelven el mismo mensaje a menos que llegue un mensaje de mayor prioridad en la cola.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. No hay ningún contexto de transacción asociado con un mensaje devuelto por una llamada a Peek.There is no transaction context associated with a message returned by a call to Peek. Dado que Peek no quita ningún mensaje de la cola, no habría nada para revertir mediante una llamada a Abort.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Usar una llamada a Receive cuando sea aceptable para el subproceso actual se bloquee mientras espera un mensaje llegue a la cola.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Dado que esta sobrecarga de la Receive método especifica un tiempo de espera infinito, la aplicación podría esperar indefinidamente.Because this overload of the Receive method specifies an infinite time-out, the application might wait indefinitely. Si el procesamiento de la aplicación debe continuar sin esperar a que el mensaje, considere la posibilidad de utilizar el método asincrónico, BeginReceive.If the application processing should continue without waiting for the message, consider using the asynchronous method, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en los distintos modos de grupo de trabajo.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabajoWorkgroup mode DisponibleAvailable
Equipo localLocal computer Yes
Equipo local y el nombre de formato directoLocal computer and direct format name Yes
Equipo remotoRemote computer NoNo
Equipo remoto y el nombre de formato directoRemote computer and direct format name Yes
Consulte también:

Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType)

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.This call is synchronous, and blocks the current thread of execution until a message is available.

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 MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType

Uno de los valores de MessageQueueTransactionType, que describe el tipo de contexto de transacción que se va a asociar al mensaje.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Devoluciones

Message que hace referencia al primer mensaje disponible en la cola.A Message that references the first message available in the queue.

Excepciones

Error al obtener acceso a un método de Message Queuing.An error occurred when accessing a Message Queuing method.

El parámetro transactionType no es un miembro de MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

Ejemplos

En el siguiente ejemplo de código se muestra el uso de Receive(MessageQueueTransactionType).The following code example demonstrates the use of 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); 

Comentarios

Utilice esta sobrecarga para recibir un mensaje de una cola mediante un contexto de transacción definido por el transactionType parámetro o espere hasta que haya mensajes en la cola.Use this overload to receive a message from a queue using a transaction context defined by the transactionType parameter, or wait until there are messages in the queue.

Especificar Automatic para el transactionType parámetro si ya existe un contexto de transacción externa asociado al subproceso que desea utilizar para recibir el mensaje.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to receive the message. Especificar Single si desea recibir el mensaje como una sola transacción interna.Specify Single if you want to receive the message as a single internal transaction. Puede especificar None si desea recibir un mensaje de una cola transaccional fuera de un contexto de transacción.You can specify None if you want to receive a message from a transactional queue outside of a transaction context.

El Receive método permite la lectura sincrónica de un mensaje, y lo quita de la cola.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Las llamadas subsiguientes a Receive devolverá los mensajes que siguen en la cola.Subsequent calls to Receive will return the messages that follow in the queue.

Si se llama a este método para recibir un mensaje desde una cola transaccional, se devolverá el mensaje recibido a la cola si se anula la transacción.If this method is called to receive a message from a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.The message is not permanently removed from the queue until the transaction is committed.

Para leer el primer mensaje en una cola sin quitarlo de la cola, utilice el Peek método.To read the first message in a queue without removing it from the queue, use the Peek method. El Peek método siempre devuelve el primer mensaje en la cola, por lo que las llamadas subsiguientes al método devuelven el mismo mensaje a menos que llegue un mensaje de mayor prioridad en la cola.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. No hay ningún contexto de transacción asociado con un mensaje devuelto por una llamada a Peek.There is no transaction context associated with a message returned by a call to Peek. Dado que Peek no quita ningún mensaje de la cola, no habría nada para revertir mediante una llamada a Abort.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Usar una llamada a Receive cuando sea aceptable para el subproceso actual se bloquee mientras espera un mensaje llegue a la cola.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Dado que esta sobrecarga de la Receive método especifica un tiempo de espera infinito, la aplicación podría esperar indefinidamente.Because this overload of the Receive method specifies an infinite time-out, the application might wait indefinitely. Si el procesamiento de la aplicación debe continuar sin esperar a que el mensaje, considere la posibilidad de utilizar el método asincrónico, BeginReceive.If the application processing should continue without waiting for the message, consider using the asynchronous method, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en los distintos modos de grupo de trabajo.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabajoWorkgroup mode DisponibleAvailable
Equipo localLocal computer Yes
Equipo local y el nombre de formato directoLocal computer and direct format name Yes
Equipo remotoRemote computer NoNo
Equipo remoto y el nombre de formato directoRemote computer and direct format name Yes
Consulte también:

Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan)

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue y espera hasta que haya un mensaje en la cola o hasta que expire el tiempo de espera.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

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 TimeSpan TimeSpan TimeSpan

TimeSpan que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.A TimeSpan that indicates the time to wait until a new message is available for inspection.

Devoluciones

Message que hace referencia al primer mensaje disponible en la cola.A Message that references the first message available in the queue.

Excepciones

El valor que especifica el parámetro timeout no es válido, quizás porque timeout es menor que Zero o mayor que InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.A message did not arrive in the queue before the time-out expired.

O bien-or-

Error al obtener acceso a un método de Message QueuingAn error occurred when accessing a Message Queuing method

Ejemplos

El ejemplo de código siguiente recibe un mensaje de una cola y envía la información sobre ese mensaje a la pantalla.The following code example receives a message from a queue and outputs information about that message to the screen. En el ejemplo se detiene la ejecución hasta cinco segundos mientras se espera un mensaje llegue a la cola.The example pauses execution for up to five seconds while waiting for a message to arrive in the queue.

#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
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 'Order


   
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 'Main


        '
        ' 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 'ReceiveMessage

End Class 'MyNewQueue

Comentarios

Utilice esta sobrecarga para recibir un mensaje y regresar en un período de tiempo especificado en caso de que no haya mensajes en la cola.Use this overload to receive a message and return in a specified period of time if there are no messages in the queue.

El Receive método permite la lectura sincrónica de un mensaje, lo quita de la cola.The Receive method allows for the synchronous reading of a message, removing it from the queue. Las llamadas subsiguientes a Receive devolverá los mensajes que siguen en la cola o nuevo, los mensajes de prioridad más alto.Subsequent calls to Receive will return the messages that follow in the queue, or new, higher priority messages.

Para leer el primer mensaje en una cola sin quitarlo de la cola, utilice el Peek método.To read the first message in a queue without removing it from the queue, use the Peek method. El Peek método siempre devuelve el primer mensaje en la cola, por lo que las llamadas subsiguientes al método devuelven el mismo mensaje a menos que llegue un mensaje de mayor prioridad en la cola.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue.

Usar una llamada a Receive cuando sea aceptable para el subproceso actual se bloquee mientras espera un mensaje llegue a la cola.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. El subproceso se bloqueará durante el período de tiempo o indefinidamente si especifica el valor InfiniteTimeout para el timeout parámetro.The thread will be blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Si el procesamiento de la aplicación debe continuar sin esperar a un mensaje, considere la posibilidad de utilizar el método asincrónico, BeginReceive.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en los distintos modos de grupo de trabajo.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabajoWorkgroup mode DisponibleAvailable
Equipo localLocal computer Yes
Equipo local y el nombre de formato directoLocal computer and direct format name Yes
Equipo remotoRemote computer NoNo
Equipo remoto y el nombre de formato directoRemote computer and direct format name Yes
Consulte también:

Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor)

Recibe el mensaje actual en la cola, utilizando un cursor especificado.Receives the current message in the queue, using a specified cursor. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.If no message is available, this method waits until either a message is available, or the time-out expires.

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

Parámetros

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

TimeSpan que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.A TimeSpan that indicates the time to wait until a new message is available for inspection.

cursor
Cursor Cursor Cursor Cursor

Un objeto Cursor que mantiene una posición específica en la cola de mensajes.A Cursor that maintains a specific position in the message queue.

Devoluciones

Message que hace referencia al primer mensaje disponible en la cola.A Message that references the first message available in the queue.

Excepciones

El valor que especifica el parámetro timeout no es válido, quizás porque timeout es menor que Zero o mayor que InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.A message did not arrive in the queue before the time-out expired.

O bien-or-

Error al obtener acceso a un método de Message QueuingAn error occurred when accessing a Message Queuing method

Utilice esta sobrecarga para recibir un mensaje y regresar en un período de tiempo especificado en caso de que no haya mensajes en la cola.Use this overload to receive a message and return in a specified period of time if there are no messages in the queue.

Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction)

Recibe el primer mensaje disponible en la cola transaccional a la que hace referencia MessageQueue y espera hasta que haya un mensaje en la cola o hasta que expire el tiempo de espera.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

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 TimeSpan TimeSpan TimeSpan

TimeSpan que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.A TimeSpan that indicates the time to wait until a new message is available for inspection.

Devoluciones

Message que hace referencia al primer mensaje disponible en la cola.A Message that references the first message available in the queue.

Excepciones

El valor que especifica el parámetro timeout no es válido, quizás porque timeout es menor que Zero o mayor que InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.A message did not arrive in the queue before the time-out expired.

O bien-or-

La cola no es transaccional.The queue is non-transactional.

O bien-or-

Error al obtener acceso a un método de Message Queuing.An error occurred when accessing a Message Queuing method.

Ejemplos

En el ejemplo de código siguiente se muestra el uso de este método.The following code example demonstrates the use of this method.

#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
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 'Main


        '**************************************************
        ' 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 'SendMessageTransactional


        '**************************************************
        ' 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 'ReceiveMessageTransactional

    End Class 'MyNewQueue
End Namespace 'MyProj

Comentarios

Utilice esta sobrecarga para recibir un mensaje de una cola transaccional utilizando el contexto de transacción interna definido por el transaction y devolverlo en un período de tiempo si hay mensajes en la cola especificado.Use this overload to receive a message from a transactional queue using the internal transaction context defined by the transaction parameter, and return within a specified period of time if there are no messages in the queue.

El Receive método permite la lectura sincrónica de un mensaje, y lo quita de la cola.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Las llamadas subsiguientes a Receive devolverá los mensajes que siguen en la cola.Subsequent calls to Receive will return the messages that follow in the queue.

Dado que este método se llama en una cola transaccional, el mensaje recibido se devolvería a la cola si se anula la transacción.Because this method is called on a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.The message is not permanently removed from the queue until the transaction is committed.

Para leer el primer mensaje en una cola sin quitarlo de la cola, utilice el Peek método.To read the first message in a queue without removing it from the queue, use the Peek method. El Peek método siempre devuelve el primer mensaje en la cola, por lo que las llamadas subsiguientes al método devuelven el mismo mensaje a menos que llegue un mensaje de mayor prioridad en la cola.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. No hay ningún contexto de transacción asociado con un mensaje devuelto por una llamada a Peek.There is no transaction context associated with a message returned by a call to Peek. Dado que Peek no quita ningún mensaje de la cola, no habría nada para revertir mediante una llamada a Abort.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Usar una llamada a Receive cuando sea aceptable para el subproceso actual se bloquee mientras espera un mensaje llegue a la cola.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. El subproceso se bloqueará durante el período de tiempo o indefinidamente si especifica el valor InfiniteTimeout para el timeout parámetro.The thread will be blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Si el procesamiento de la aplicación debe continuar sin esperar a un mensaje, considere la posibilidad de utilizar el método asincrónico, BeginReceive.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en los distintos modos de grupo de trabajo.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabajoWorkgroup mode DisponibleAvailable
Equipo localLocal computer Yes
Equipo local y el nombre de formato directoLocal computer and direct format name Yes
Equipo remotoRemote computer NoNo
Equipo remoto y el nombre de formato directoRemote computer and direct format name Yes
Consulte también:

Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType)

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. La llamada es sincrónica y espera hasta que haya un mensaje disponible en la cola o hasta que expira el tiempo de espera.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

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 TimeSpan TimeSpan TimeSpan

TimeSpan que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.A TimeSpan that indicates the time to wait until a new message is available for inspection.

transactionType
MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType

Uno de los valores de MessageQueueTransactionType, que describe el tipo de contexto de transacción que se va a asociar al mensaje.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Devoluciones

Message que hace referencia al primer mensaje disponible en la cola.A Message that references the first message available in the queue.

Excepciones

El valor que especifica el parámetro timeout no es válido, quizás porque timeout es menor que Zero o mayor que InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

El parámetro transactionType no es un miembro de MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.A message did not arrive in the queue before the time-out expired.

O bien-or-

Error al obtener acceso a un método de Message Queuing.An error occurred when accessing a Message Queuing method.

Ejemplos

En el ejemplo de código siguiente se muestra el uso de este método.The following code example demonstrates the use of this method.


// 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);

Comentarios

Utilice esta sobrecarga para recibir un mensaje de una cola mediante un contexto de transacción definido por el transactionType y devolverlo en un periodo de tiempo si hay mensajes en la cola.Use this overload to receive a message from a queue using a transaction context defined by the transactionType parameter, and return in a specified period of time if there are no messages in the queue.

Especificar Automatic para el transactionType parámetro si ya existe un contexto de transacción externa asociado al subproceso que desea utilizar para recibir el mensaje.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to receive the message. Especificar Single si desea recibir el mensaje como una sola transacción interna.Specify Single if you want to receive the message as a single internal transaction. Puede especificar None si desea recibir un mensaje de una cola transaccional fuera de un contexto de transacción.You can specify None if you want to receive a message from a transactional queue outside of a transaction context.

El Receive método permite la lectura sincrónica de un mensaje, y lo quita de la cola.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Las llamadas subsiguientes a Receive devolverá los mensajes que siguen en la cola.Subsequent calls to Receive will return the messages that follow in the queue.

Si se llama a este método para recibir un mensaje desde una cola transaccional, se devolverá el mensaje recibido a la cola si se anula la transacción.If this method is called to receive a message from a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.The message is not permanently removed from the queue until the transaction is committed.

Para leer el primer mensaje en una cola sin quitarlo de la cola, utilice el Peek método.To read the first message in a queue without removing it from the queue, use the Peek method. El Peek método siempre devuelve el primer mensaje en la cola, por lo que las llamadas subsiguientes al método devuelven el mismo mensaje a menos que llegue un mensaje de mayor prioridad en la cola.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. No hay ningún contexto de transacción asociado con un mensaje devuelto por una llamada a Peek.There is no transaction context associated with a message returned by a call to Peek. Dado que Peek no quita ningún mensaje de la cola, no habría nada para revertir mediante una llamada a Abort.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Usar una llamada a Receive cuando sea aceptable para el subproceso actual se bloquee mientras espera un mensaje llegue a la cola.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. El subproceso se bloqueará durante el período de tiempo o indefinidamente si especifica el valor InfiniteTimeout para el timeout parámetro.The thread will be blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Si el procesamiento de la aplicación debe continuar sin esperar a un mensaje, considere la posibilidad de utilizar el método asincrónico, BeginReceive.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en los distintos modos de grupo de trabajo.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabajoWorkgroup mode DisponibleAvailable
Equipo localLocal computer Yes
Equipo local y el nombre de formato directoLocal computer and direct format name Yes
Equipo remotoRemote computer NoNo
Equipo remoto y el nombre de formato directoRemote computer and direct format name Yes
Consulte también:

Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction)

Recibe el mensaje actual en la cola, utilizando un cursor especificado.Receives the current message in the queue, using a specified cursor. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.If no message is available, this method waits until either a message is available, or the time-out expires.

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

Parámetros

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

TimeSpan que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.A TimeSpan that indicates the time to wait until a new message is available for inspection.

cursor
Cursor Cursor Cursor Cursor

Un objeto Cursor que mantiene una posición específica en la cola de mensajes.A Cursor that maintains a specific position in the message queue.

Devoluciones

Un objeto Message que hace referencia a un mensaje de la cola.A Message that references a message in the queue.

Excepciones

El parámetro cursor es null.The cursor parameter is null.

O bien-or- El parámetro transaction es null.The transaction parameter is null.

El valor especificado para el parámetro timeout no es válido.The value specified for the timeout parameter is not valid. Probablemente timeout es menor que Zero o mayor que InfiniteTimeout.Possibly timeout is less than Zero or greater than InfiniteTimeout.

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.A message did not arrive in the queue before the time-out expired.

O bien-or-

La cola no es transaccional.The queue is non-transactional.

O bien-or-

Error al obtener acceso a un método de Message Queuing.An error occurred when accessing a Message Queuing method.

Comentarios

Utilice esta sobrecarga para recibir un mensaje de una cola transaccional utilizando el contexto de transacción interna definido por el transaction y devolverlo en un período de tiempo si hay mensajes en la cola especificado.Use this overload to receive a message from a transactional queue using the internal transaction context defined by the transaction parameter, and return within a specified period of time if there are no messages in the queue.

El Receive método permite la lectura sincrónica de un mensaje, y lo quita de la cola.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Las llamadas subsiguientes a Receive devolver los mensajes que siguen en la cola.Subsequent calls to Receive return the messages that follow in the queue.

Dado que este método se llama en una cola transaccional, el mensaje recibido se devuelve a la cola si se anula la transacción.Because this method is called on a transactional queue, the message that is received is returned to the queue if the transaction is aborted. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.The message is not permanently removed from the queue until the transaction is committed.

Para leer un mensaje en una cola sin quitarlo de la cola, utilice el Peek método.To read a message in a queue without removing it from the queue, use the Peek method. No hay ningún contexto de transacción asociado con un mensaje devuelto por una llamada a Peek.There is no transaction context associated with a message returned by a call to Peek. Dado que Peek no quita ningún mensaje de la cola, no hay nada para revertir mediante una llamada a Abort.Because Peek does not remove any messages in the queue, there is nothing to roll back by a call to Abort.

Usar una llamada a Receive cuando sea aceptable para el subproceso actual se bloquee mientras espera un mensaje llegue a la cola.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. El subproceso se bloquea durante el período de tiempo o indefinidamente si especifica el valor InfiniteTimeout para el timeout parámetro.The thread is blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Si el procesamiento de la aplicación debe continuar sin esperar a un mensaje, considere la posibilidad de utilizar el método asincrónico, BeginReceive.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en los distintos modos de grupo de trabajo.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabajoWorkgroup mode DisponibleAvailable
Equipo localLocal computer Yes
Equipo local y el nombre de formato directoLocal computer and direct format name Yes
Equipo remotoRemote computer NoNo
Equipo remoto y el nombre de formato directoRemote computer and direct format name Yes
Consulte también:

Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Recibe el mensaje actual en la cola, utilizando un cursor especificado.Receives the current message in the queue, using a specified cursor. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.If no message is available, this method waits until either a message is available, or the time-out expires.

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

Parámetros

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

TimeSpan que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.A TimeSpan that indicates the time to wait until a new message is available for inspection.

cursor
Cursor Cursor Cursor Cursor

Un objeto Cursor que mantiene una posición específica en la cola de mensajes.A Cursor that maintains a specific position in the message queue.

transactionType
MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType

Uno de los valores de MessageQueueTransactionType que describe el tipo de contexto de transacción que se asocia al mensaje.One of the MessageQueueTransactionType values that describes the type of transaction context to associate with the message.

Devoluciones

Un objeto Message que hace referencia a un mensaje de la cola.A Message that references a message in the queue.

Excepciones

El parámetro cursor es null.The cursor parameter is null.

El valor especificado para el parámetro timeout no es válido.The value specified for the timeout parameter is not valid. Probablemente timeout es menor que Zero o mayor que InfiniteTimeout.Possibly timeout is less than Zero or greater than InfiniteTimeout.

El parámetro transactionType no es un miembro de MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.A message did not arrive in the queue before the time-out expired.

O bien-or-

Error al obtener acceso a un método de Message Queuing.An error occurred when accessing a Message Queuing method.

Comentarios

Utilice esta sobrecarga para recibir un mensaje de una cola mediante un contexto de transacción definido por el transactionType y devolverlo en un periodo de tiempo si hay mensajes en la cola.Use this overload to receive a message from a queue using a transaction context defined by the transactionType parameter, and return in a specified period of time if there are no messages in the queue.

Especificar Automatic para el transactionType parámetro si ya existe un contexto de transacción externa asociado al subproceso que desea utilizar para recibir el mensaje.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to receive the message. Especificar Single si desea recibir el mensaje como una sola transacción interna.Specify Single if you want to receive the message as a single internal transaction. Puede especificar None si desea recibir un mensaje de una cola transaccional fuera de un contexto de transacción.You can specify None if you want to receive a message from a transactional queue outside of a transaction context.

El Receive método permite la lectura sincrónica de un mensaje, y lo quita de la cola.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Las llamadas subsiguientes a Receive devolver los mensajes que siguen en la cola.Subsequent calls to Receive return the messages that follow in the queue.

Si se llama a este método para recibir un mensaje desde una cola transaccional, el mensaje recibido se devuelve a la cola si se anula la transacción.If this method is called to receive a message from a transactional queue, the message that is received is returned to the queue if the transaction is aborted. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.The message is not permanently removed from the queue until the transaction is committed.

Para leer un mensaje en una cola sin quitarlo de la cola, utilice el Peek método.To read a message in a queue without removing it from the queue, use the Peek method. No hay ningún contexto de transacción asociado con un mensaje devuelto por una llamada a Peek.There is no transaction context associated with a message returned by a call to Peek. Dado que Peek no quita ningún mensaje de la cola, no hay nada para revertir mediante una llamada a Abort.Because Peek does not remove any messages in the queue, there is nothing to roll back by a call to Abort.

Usar una llamada a Receive cuando sea aceptable para el subproceso actual se bloquee mientras espera un mensaje llegue a la cola.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. El subproceso se bloquea durante el período de tiempo o indefinidamente si especifica el valor InfiniteTimeout para el timeout parámetro.The thread is blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Si el procesamiento de la aplicación debe continuar sin esperar a un mensaje, considere la posibilidad de utilizar el método asincrónico, BeginReceive.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en los distintos modos de grupo de trabajo.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabajoWorkgroup mode DisponibleAvailable
Equipo localLocal computer Yes
Equipo local y el nombre de formato directoLocal computer and direct format name Yes
Equipo remotoRemote computer NoNo
Equipo remoto y el nombre de formato directoRemote computer and direct format name Yes
Consulte también:

Se aplica a