Compartir a través de

MessageQueue.Receive Método

  • Referencia

Definición

Espacio de nombres:
System.Messaging
Ensamblado:
System.Messaging.dll

Recibe el primer mensaje de la cola y lo quita de esta.

Sobrecargas

Receive()

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.
Receive(MessageQueueTransaction)

Recibe el primer mensaje disponible en la cola transaccional a la que hace referencia MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.
Receive(MessageQueueTransactionType)

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.
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.
Receive(TimeSpan, Cursor)

Recibe el mensaje actual en la cola, utilizando un cursor especificado. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.
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.
Receive(TimeSpan, MessageQueueTransactionType)

Recibe el primer mensaje disponible en la cola a la que hace referencia 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.
Receive(TimeSpan, Cursor, MessageQueueTransaction)

Recibe el mensaje actual en la cola, utilizando un cursor especificado. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Recibe el mensaje actual en la cola, utilizando un cursor especificado. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.

Receive()

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.

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

Devoluciones

Message

Message que hace referencia al primer mensaje disponible en la cola.

Excepciones

MessageQueueException

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En el ejemplo de código siguiente se recibe un mensaje de una cola y se genera información sobre ese mensaje en la pantalla.

#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

Comentarios

Use esta sobrecarga para recibir un mensaje de una cola o espere hasta que haya mensajes en la cola.

El Receive método permite la lectura sincrónica de un mensaje, lo que lo quita de la cola. Las llamadas posteriores a Receive devolverán los mensajes que siguen en la cola, o mensajes de prioridad superior nuevos.

Para leer el primer mensaje de una cola sin quitarlo de la cola, use el Peek método . El Peek método siempre devuelve el primer mensaje de la cola, por lo que las llamadas posteriores al método devuelven el mismo mensaje a menos que llegue un mensaje de prioridad más alta en la cola.

Use una llamada a Receive cuando sea aceptable que el subproceso actual se bloquee mientras espera a que llegue un mensaje a la cola. Dado que esta sobrecarga del Receive método especifica un tiempo de espera infinito, la aplicación puede esperar indefinidamente. Si el procesamiento de la aplicación debe continuar sin esperar el mensaje, considere la posibilidad de usar el método asincrónico, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local Sí
Equipo local y nombre de formato directo Sí
Equipo remoto No
Equipo remoto y nombre de formato directo Sí

Consulte también

Se aplica a

Receive(MessageQueueTransaction)

Recibe el primer mensaje disponible en la cola transaccional a la que hace referencia MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.

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

Objeto MessageQueueTransaction.

Devoluciones

Message

Message que hace referencia al primer mensaje disponible en la cola.

Excepciones

MessageQueueException

Error al obtener acceso a un método de Message Queuing.

o bien

La cola no es transaccional.

Ejemplos

El ejemplo de código siguiente se conecta a una cola transaccional en el equipo local y envía un mensaje a la cola. A continuación, recibe el mensaje que contiene un pedido. Si encuentra una cola no transaccional, se producirá una excepción y se revertirá la transacción.

#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

Comentarios

Use esta sobrecarga para recibir un mensaje de una cola transaccional mediante el contexto de transacción interno definido por el transaction parámetro o espere hasta que haya mensajes en la cola.

El Receive método permite la lectura sincrónica de un mensaje, lo que lo quita de la cola. Las llamadas posteriores a Receive devolverán los mensajes que siguen en la cola.

Dado que se llama a este método en una cola transaccional, el mensaje que se recibe se devolverá a la cola si se anula la transacción. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.

Para leer el primer mensaje de una cola sin quitarlo de la cola, use el Peek método . El Peek método siempre devuelve el primer mensaje de la cola, por lo que las llamadas posteriores al método devuelven el mismo mensaje a menos que llegue un mensaje de prioridad más alta en la cola. No hay ningún contexto de transacción asociado a un mensaje devuelto por una llamada a Peek. Dado que Peek no quita ningún mensaje de la cola, no habría nada que revertir mediante una llamada a Abort.

Use una llamada a Receive cuando sea aceptable que el subproceso actual se bloquee mientras espera a que llegue un mensaje a la cola. Dado que esta sobrecarga del Receive método especifica un tiempo de espera infinito, la aplicación puede esperar indefinidamente. Si el procesamiento de la aplicación debe continuar sin esperar el mensaje, considere la posibilidad de usar el método asincrónico, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local Sí
Equipo local y nombre de formato directo Sí
Equipo remoto No
Equipo remoto y nombre de formato directo Sí

Consulte también

Se aplica a

Receive(MessageQueueTransactionType)

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.

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

Uno de los valores de MessageQueueTransactionType, que describe el tipo de contexto de transacción que se va a asociar al mensaje.

Devoluciones

Message

Message que hace referencia al primer mensaje disponible en la cola.

Excepciones

MessageQueueException

Error al obtener acceso a un método de Message Queuing.

InvalidEnumArgumentException

El parámetro transactionType no es un miembro de MessageQueueTransactionType.

Ejemplos

En el siguiente ejemplo de código se muestra el 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);

Comentarios

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

Especifique Automatic para el transactionType parámetro si ya hay un contexto de transacción externo asociado al subproceso que desea usar para recibir el mensaje. Especifique Single si desea recibir el mensaje como una única transacción interna. Puede especificar None si desea recibir un mensaje de una cola transaccional fuera de un contexto de transacción.

El Receive método permite la lectura sincrónica de un mensaje, lo que lo quita de la cola. Las llamadas posteriores a Receive devolverán los mensajes que siguen en la cola.

Si se llama a este método para recibir un mensaje de una cola transaccional, el mensaje que se recibe se devolverá a la cola si se anula la transacción. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.

Para leer el primer mensaje de una cola sin quitarlo de la cola, use el Peek método . El Peek método siempre devuelve el primer mensaje de la cola, por lo que las llamadas posteriores al método devuelven el mismo mensaje a menos que llegue un mensaje de prioridad más alta en la cola. No hay ningún contexto de transacción asociado a un mensaje devuelto por una llamada a Peek. Dado que Peek no quita ningún mensaje de la cola, no habría nada que revertir mediante una llamada a Abort.

Use una llamada a Receive cuando sea aceptable que el subproceso actual se bloquee mientras espera a que llegue un mensaje a la cola. Dado que esta sobrecarga del Receive método especifica un tiempo de espera infinito, la aplicación puede esperar indefinidamente. Si el procesamiento de la aplicación debe continuar sin esperar el mensaje, considere la posibilidad de usar el método asincrónico, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local Sí
Equipo local y nombre de formato directo Sí
Equipo remoto No
Equipo remoto y nombre de formato directo Sí

Consulte también

Se aplica a

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.

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 que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.

Devoluciones

Message

Message que hace referencia al primer mensaje disponible en la cola.

Excepciones

ArgumentException

El valor que especifica el parámetro timeout no es válido, quizás porque timeout es menor que Zero o mayor que InfiniteTimeout.

MessageQueueException

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.

o bien

Error al obtener acceso a un método de Message Queuing

Ejemplos

En el ejemplo de código siguiente se recibe un mensaje de una cola y se genera información sobre ese mensaje en la pantalla. En el ejemplo se detiene la ejecución durante un máximo de cinco segundos mientras se espera a que llegue un mensaje a la cola.

#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

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.

El Receive método permite la lectura sincrónica de un mensaje, lo que lo quita de la cola. Las llamadas posteriores a Receive devolverán los mensajes que siguen en la cola, o mensajes de prioridad superior nuevos.

Para leer el primer mensaje de una cola sin quitarlo de la cola, use el Peek método . El Peek método siempre devuelve el primer mensaje de la cola, por lo que las llamadas posteriores al método devuelven el mismo mensaje a menos que llegue un mensaje de prioridad más alta en la cola.

Use una llamada a Receive cuando sea aceptable que el subproceso actual se bloquee mientras espera a que llegue un mensaje a la cola. El subproceso se bloqueará durante el período de tiempo especificado o indefinidamente si especificó el valor InfiniteTimeout del timeout parámetro . Si el procesamiento de la aplicación debe continuar sin esperar un mensaje, considere la posibilidad de usar el método asincrónico, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local Sí
Equipo local y nombre de formato directo Sí
Equipo remoto No
Equipo remoto y nombre de formato directo Sí

Consulte también

Se aplica a

Receive(TimeSpan, Cursor)

Recibe el mensaje actual en la cola, utilizando un cursor especificado. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.

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

TimeSpan que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.

cursor
Cursor

Un objeto Cursor que mantiene una posición específica en la cola de mensajes.

Devoluciones

Message

Message que hace referencia al primer mensaje disponible en la cola.

Excepciones

ArgumentException

El valor que especifica el parámetro timeout no es válido, quizás porque timeout es menor que Zero o mayor que InfiniteTimeout.

MessageQueueException

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.

o bien

Error al obtener acceso a un método de Message Queuing

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.

Se aplica a

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.

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 que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.

transaction
MessageQueueTransaction

Objeto MessageQueueTransaction.

Devoluciones

Message

Message que hace referencia al primer mensaje disponible en la cola.

Excepciones

ArgumentException

El valor que especifica el parámetro timeout no es válido, quizás porque timeout es menor que Zero o mayor que InfiniteTimeout.

MessageQueueException

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.

o bien

La cola no es transaccional.

o bien

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En el ejemplo de código siguiente se muestra el uso de este 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

Comentarios

Use esta sobrecarga para recibir un mensaje de una cola transaccional mediante el contexto de transacción interno definido por el transaction parámetro y devolver dentro de un período de tiempo especificado si no hay ningún mensaje en la cola.

El Receive método permite la lectura sincrónica de un mensaje, lo que lo quita de la cola. Las llamadas posteriores a Receive devolverán los mensajes que siguen en la cola.

Dado que se llama a este método en una cola transaccional, el mensaje que se recibe se devolverá a la cola si se anula la transacción. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.

Para leer el primer mensaje de una cola sin quitarlo de la cola, use el Peek método . El Peek método siempre devuelve el primer mensaje de la cola, por lo que las llamadas posteriores al método devuelven el mismo mensaje a menos que llegue un mensaje de prioridad más alta en la cola. No hay ningún contexto de transacción asociado a un mensaje devuelto por una llamada a Peek. Dado que Peek no quita ningún mensaje de la cola, no habría nada que revertir mediante una llamada a Abort.

Use una llamada a Receive cuando sea aceptable que el subproceso actual se bloquee mientras espera a que llegue un mensaje a la cola. El subproceso se bloqueará durante el período de tiempo especificado o indefinidamente si especificó el valor InfiniteTimeout del timeout parámetro . Si el procesamiento de la aplicación debe continuar sin esperar un mensaje, considere la posibilidad de usar el método asincrónico, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local Sí
Equipo local y nombre de formato directo Sí
Equipo remoto No
Equipo remoto y nombre de formato directo Sí

Consulte también

Se aplica a

Receive(TimeSpan, MessageQueueTransactionType)

Recibe el primer mensaje disponible en la cola a la que hace referencia 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.

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 que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.

transactionType
MessageQueueTransactionType

Uno de los valores de MessageQueueTransactionType, que describe el tipo de contexto de transacción que se va a asociar al mensaje.

Devoluciones

Message

Message que hace referencia al primer mensaje disponible en la cola.

Excepciones

ArgumentException

El valor que especifica el parámetro timeout no es válido, quizás porque timeout es menor que Zero o mayor que InfiniteTimeout.

InvalidEnumArgumentException

El parámetro transactionType no es un miembro de MessageQueueTransactionType.

MessageQueueException

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.

o bien

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En el ejemplo de código siguiente se muestra el uso de este 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);

Comentarios

Use esta sobrecarga para recibir un mensaje de una cola mediante un contexto de transacción definido por el transactionType parámetro y devolver en un período de tiempo especificado si no hay ningún mensaje en la cola.

Especifique Automatic para el transactionType parámetro si ya hay un contexto de transacción externo asociado al subproceso que desea usar para recibir el mensaje. Especifique Single si desea recibir el mensaje como una única transacción interna. Puede especificar None si desea recibir un mensaje de una cola transaccional fuera de un contexto de transacción.

El Receive método permite la lectura sincrónica de un mensaje, lo que lo quita de la cola. Las llamadas posteriores a Receive devolverán los mensajes que siguen en la cola.

Si se llama a este método para recibir un mensaje de una cola transaccional, el mensaje que se recibe se devolverá a la cola si se anula la transacción. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.

Para leer el primer mensaje de una cola sin quitarlo de la cola, use el Peek método . El Peek método siempre devuelve el primer mensaje de la cola, por lo que las llamadas posteriores al método devuelven el mismo mensaje a menos que llegue un mensaje de prioridad más alta en la cola. No hay ningún contexto de transacción asociado a un mensaje devuelto por una llamada a Peek. Dado que Peek no quita ningún mensaje de la cola, no habría nada que revertir mediante una llamada a Abort.

Use una llamada a Receive cuando sea aceptable que el subproceso actual se bloquee mientras espera a que llegue un mensaje a la cola. El subproceso se bloqueará durante el período de tiempo especificado o indefinidamente si especificó el valor InfiniteTimeout del timeout parámetro . Si el procesamiento de la aplicación debe continuar sin esperar un mensaje, considere la posibilidad de usar el método asincrónico, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local Sí
Equipo local y nombre de formato directo Sí
Equipo remoto No
Equipo remoto y nombre de formato directo Sí

Consulte también

Se aplica a

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Recibe el mensaje actual en la cola, utilizando un cursor especificado. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.

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

TimeSpan que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.

cursor
Cursor

Un objeto Cursor que mantiene una posición específica en la cola de mensajes.

transaction
MessageQueueTransaction

Objeto MessageQueueTransaction.

Devoluciones

Message

Un objeto Message que hace referencia a un mensaje de la cola.

Excepciones

ArgumentNullException

El parámetro cursor es null.

o bien

El parámetro transaction es null.

ArgumentException

El valor especificado para el parámetro timeout no es válido. Probablemente timeout es menor que Zero o mayor que InfiniteTimeout.

MessageQueueException

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.

o bien

La cola no es transaccional.

o bien

Error al obtener acceso a un método de Message Queuing.

Comentarios

Use esta sobrecarga para recibir un mensaje de una cola transaccional mediante el contexto de transacción interno definido por el transaction parámetro y devolver dentro de un período de tiempo especificado si no hay ningún mensaje en la cola.

El Receive método permite la lectura sincrónica de un mensaje, lo que lo quita de la cola. Las llamadas posteriores para Receive devolver los mensajes siguientes en la cola.

Dado que se llama a este método en una cola transaccional, el mensaje que se recibe se devuelve a la cola si se anula la transacción. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.

Para leer un mensaje en una cola sin quitarlo de la cola, use el Peek método . No hay ningún contexto de transacción asociado a un mensaje devuelto por una llamada a Peek. Dado que Peek no quita ningún mensaje de la cola, no hay nada que revertir mediante una llamada a Abort.

Use una llamada a Receive cuando sea aceptable que el subproceso actual se bloquee mientras espera a que llegue un mensaje a la cola. El subproceso se bloquea durante el período de tiempo especificado o indefinidamente si especificó el valor InfiniteTimeout del timeout parámetro . Si el procesamiento de la aplicación debe continuar sin esperar un mensaje, considere la posibilidad de usar el método asincrónico, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local Sí
Equipo local y nombre de formato directo Sí
Equipo remoto No
Equipo remoto y nombre de formato directo Sí

Consulte también

Se aplica a

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Recibe el mensaje actual en la cola, utilizando un cursor especificado. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.

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

TimeSpan que indica el tiempo que hay que esperar hasta que haya un nuevo mensaje disponible para inspección.

cursor
Cursor

Un objeto Cursor que mantiene una posición específica en la cola de mensajes.

transactionType
MessageQueueTransactionType

Uno de los valores de MessageQueueTransactionType que describe el tipo de contexto de transacción que se asocia al mensaje.

Devoluciones

Message

Un objeto Message que hace referencia a un mensaje de la cola.

Excepciones

ArgumentNullException

El parámetro cursor es null.

ArgumentException

El valor especificado para el parámetro timeout no es válido. Probablemente timeout es menor que Zero o mayor que InfiniteTimeout.

InvalidEnumArgumentException

El parámetro transactionType no es un miembro de MessageQueueTransactionType.

MessageQueueException

No llegó ningún mensaje a la cola antes de que expirara el tiempo de espera.

o bien

Error al obtener acceso a un método de Message Queuing.

Comentarios

Use esta sobrecarga para recibir un mensaje de una cola mediante un contexto de transacción definido por el transactionType parámetro y devolver en un período de tiempo especificado si no hay ningún mensaje en la cola.

Especifique Automatic para el transactionType parámetro si ya hay un contexto de transacción externo asociado al subproceso que desea usar para recibir el mensaje. Especifique Single si desea recibir el mensaje como una única transacción interna. Puede especificar None si desea recibir un mensaje de una cola transaccional fuera de un contexto de transacción.

El Receive método permite la lectura sincrónica de un mensaje, lo que lo quita de la cola. Las llamadas posteriores para Receive devolver los mensajes siguientes en la cola.

Si se llama a este método para recibir un mensaje de una cola transaccional, el mensaje que se recibe se devuelve a la cola si se anula la transacción. El mensaje no se quita permanentemente de la cola hasta que se confirma la transacción.

Para leer un mensaje en una cola sin quitarlo de la cola, use el Peek método . No hay ningún contexto de transacción asociado a un mensaje devuelto por una llamada a Peek. Dado que Peek no quita ningún mensaje de la cola, no hay nada que revertir mediante una llamada a Abort.

Use una llamada a Receive cuando sea aceptable que el subproceso actual se bloquee mientras espera a que llegue un mensaje a la cola. El subproceso se bloquea durante el período de tiempo especificado o indefinidamente si especificó el valor InfiniteTimeout del timeout parámetro . Si el procesamiento de la aplicación debe continuar sin esperar un mensaje, considere la posibilidad de usar el método asincrónico, BeginReceive.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local Sí
Equipo local y nombre de formato directo Sí
Equipo remoto No
Equipo remoto y nombre de formato directo Sí

Consulte también

Se aplica a

Seguridad para subprocesos

El método no es seguro para subprocesos.