Comparteix a través de

MessageQueue.BeginReceive Método

  • Referencia

Definición

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

Inicia una operación de recepción asincrónica al indicar a Message Queuing que empiece a recibir un mensaje y que lo notifique al controlador de eventos cuando haya terminado.

Sobrecargas

BeginReceive()

Inicia una operación de recepción asincrónica sin tiempo de espera. La operación no se completa hasta que haya un mensaje disponible en la cola.
BeginReceive(TimeSpan)

Inicia una operación de recepción asincrónica que tiene un tiempo de espera especificado. La operación no se completa hasta que haya un mensaje disponible en la cola o hasta que se agote el tiempo de espera.
BeginReceive(TimeSpan, Object)

Inicia una operación de recepción asincrónica con un tiempo de espera y un objeto de estado específicos, lo que proporciona información relacionada durante toda la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.
BeginReceive(TimeSpan, Object, AsyncCallback)

Inicia una operación de recepción asincrónica con un tiempo de espera y un objeto de estado específicos, lo que proporciona información relacionada durante toda la operación. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Inicia una operación de recepción asincrónica que tiene especificado un tiempo de espera y utiliza un cursor y un objeto de estado especificados. El objeto de estado proporciona la información asociada a lo largo del período de duración de la operación. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.

BeginReceive()

Inicia una operación de recepción asincrónica sin tiempo de espera. La operación no se completa hasta que haya un mensaje disponible en la cola.

public:
 IAsyncResult ^ BeginReceive();
public IAsyncResult BeginReceive ();
member this.BeginReceive : unit -> IAsyncResult
Public Function BeginReceive () As IAsyncResult

Devoluciones

IAsyncResult

IAsyncResult que identifica la solicitud asincrónica publicada.

Excepciones

MessageQueueException

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

Ejemplos

En el ejemplo de código siguiente se encadena solicitudes asincrónicas. Se supone que hay una cola en el equipo local denominado "myQueue". La Main función inicia la operación asincrónica que controla la MyReceiveCompleted rutina. MyReceiveCompleted procesa el mensaje actual y comienza una nueva operación de recepción asincrónica.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Define static class members.
   static ManualResetEvent^ signal = gcnew ManualResetEvent( false );
   static int count = 0;

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );
         count += 1;
         if ( count == 10 )
         {
            signal->Set();
         }

         // Restart the asynchronous receive operation.
         mq->BeginReceive();
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// operation processing.
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Begin the asynchronous receive operation.
   myQueue->BeginReceive();
   MyNewQueue::signal->WaitOne();

   // Do other work on the current thread.
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {
        // Define static class members.
        static ManualResetEvent signal = new ManualResetEvent(false);
        static int count = 0;

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // operation processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Begin the asynchronous receive operation.
            myQueue.BeginReceive();

            signal.WaitOne();
            
            // Do other work on the current thread.

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
                
                count += 1;
                if (count == 10)
                {
                    signal.Set();
                }

                // Restart the asynchronous receive operation.
                mq.BeginReceive();
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading




' Provides a container class for the example.

Public Class MyNewQueue

        ' Define static class members.
        Private Shared signal As New ManualResetEvent(False)
        Private Shared count As Integer = 0



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' operation processing.


        Public Shared Sub Main()
            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Begin the asynchronous receive operation.
            myQueue.BeginReceive()

            signal.WaitOne()

            ' Do other work on the current thread.

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = CType([source], MessageQueue)

                ' End the asynchronous receive operation.
                Dim m As Message = _
                    mq.EndReceive(asyncResult.AsyncResult)

                count += 1
                If count = 10 Then
                    signal.Set()
                End If

                ' Restart the asynchronous receive operation.
                mq.BeginReceive()

            Catch
                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

En el ejemplo de código siguiente se ponen en cola solicitudes asincrónicas. La llamada a BeginReceive usa en AsyncWaitHandle su valor devuelto. La Main rutina espera a que se completen todas las operaciones asincrónicas antes de salir.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );

         // Process the message here.
         Console::WriteLine( "Message received." );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }
      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// operation processing.
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Define wait handles for multiple operations.
   array<WaitHandle^>^waitHandleArray = gcnew array<WaitHandle^>(10);
   for ( int i = 0; i < 10; i++ )
   {
      // Begin asynchronous operations.
      waitHandleArray[ i ] = myQueue->BeginReceive()->AsyncWaitHandle;
   }

   // Specify to wait for all operations to return.
   WaitHandle::WaitAll( waitHandleArray );
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

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

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // operation processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Define wait handles for multiple operations.
            WaitHandle[] waitHandleArray = new WaitHandle[10];
            for(int i=0; i<10; i++)
            {
                // Begin asynchronous operations.
                waitHandleArray[i] =
                    myQueue.BeginReceive().AsyncWaitHandle;
            }

            // Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray);

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
        
                // Process the message here.
                Console.WriteLine("Message received.");
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading


' Provides a container class for the example.

Public Class MyNewQueue


        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' operation processing.


        Public Shared Sub Main()

            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Define wait handles for multiple operations.
            Dim waitHandleArray(10) As WaitHandle

            Dim i As Integer
            For i = 0 To 9
                ' Begin asynchronous operations.
                waitHandleArray(i) = _
                    myQueue.BeginReceive().AsyncWaitHandle
            Next i

            ' Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray)

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = CType([source], MessageQueue)

                ' End the asynchronous receive operation.
                Dim m As Message = _
                    mq.EndReceive(asyncResult.AsyncResult)

                ' Process the message here.
                Console.WriteLine("Message received.")

            Catch

                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Comentarios

En el procesamiento asincrónico, se usa BeginReceive para generar el ReceiveCompleted evento cuando se ha quitado un mensaje de la cola.

ReceiveCompleted también se genera si ya existe un mensaje en la cola.

Para usar BeginReceive, cree un controlador de eventos que procese los resultados de la operación asincrónica y asócielo con el delegado de eventos. BeginReceive inicia una operación de recepción asincrónica; MessageQueue se notifica, a través de la generación del ReceiveCompleted evento, cuando llega un mensaje a la cola. A MessageQueue continuación, puede acceder al mensaje llamando a EndReceive(IAsyncResult).

El BeginReceive método devuelve inmediatamente, pero la operación asincrónica no se completa hasta que se llama al controlador de eventos.

Dado BeginReceive que es asincrónico, puede llamarlo para recibir un mensaje de la cola sin bloquear el subproceso actual de ejecución. Para recibir un mensaje de forma sincrónica, use el Receive método .

Una vez completada una operación asincrónica, puede llamar o BeginReceive volver a llamar BeginPeek al controlador de eventos para seguir recibiendo notificaciones.

que IAsyncResultBeginReceive devuelve identifica la operación asincrónica que inició el método. Puede usarlo IAsyncResult durante toda la duración de la operación, aunque generalmente no lo use hasta EndReceive(IAsyncResult) que se llame a . Sin embargo, si inicia varias operaciones asincrónicas, puede colocar sus IAsyncResult valores en una matriz y especificar si se debe esperar a que se completen todas las operaciones o cualquier operación. En este caso, se usa la AsyncWaitHandle propiedad de IAsyncResult para identificar la operación completada.

Si CanRead es false, se genera el evento de finalización, pero se producirá una excepción al llamar a EndReceive(IAsyncResult).

No use la llamada BeginReceive asincrónica con transacciones. Si desea realizar una operación asincrónica transaccional, llame BeginPeeka y coloque la transacción y el método (sincrónico) Receive dentro del controlador de eventos que cree para la operación de inspección. El controlador de eventos puede contener funcionalidad como se muestra en el siguiente código de C#.

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

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

BeginReceive(TimeSpan)

Inicia una operación de recepción asincrónica que tiene un tiempo de espera especificado. La operación no se completa hasta que haya un mensaje disponible en la cola o hasta que se agote el tiempo de espera.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);
public IAsyncResult BeginReceive (TimeSpan timeout);
member this.BeginReceive : TimeSpan -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

Parámetros

timeout
TimeSpan

TimeSpan que indica el intervalo de tiempo que hay que esperar a que haya un mensaje disponible.

Devoluciones

IAsyncResult

IAsyncResult que identifica la solicitud asincrónica publicada.

Excepciones

ArgumentException

El valor especificado para el parámetro timeout no es válido, posiblemente porque representa un número negativo.

MessageQueueException

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

Ejemplos

En el ejemplo de código siguiente se crea una operación de recepción asincrónica. En el ejemplo de código se crea un controlador de eventos, MyReceiveCompletedy se adjunta al delegado del ReceiveCompleted controlador de eventos. El ejemplo de código envía un mensaje a una cola de mensajes local y, a continuación, llama a BeginReceive(TimeSpan), pasando un valor de tiempo de espera de diez segundos. Cuando se genera un ReceiveCompleted evento, el controlador de eventos recibe el mensaje y escribe el cuerpo del mensaje en la pantalla.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message body: {0}", msg->Body);
    
    queue->Close();
}

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }

    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }

}


using System;
using System.Messaging;

public class QueueExample
{
    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
                ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Comentarios

En el procesamiento asincrónico, se usa BeginReceive para generar el ReceiveCompleted evento cuando un mensaje está disponible en la cola o cuando el intervalo de tiempo especificado ha expirado.

ReceiveCompleted también se genera si ya existe un mensaje en la cola.

Para usar BeginReceive, cree un controlador de eventos que procese los resultados de la operación asincrónica y asócielo con el delegado de eventos. BeginReceive inicia una operación de recepción asincrónica; MessageQueue se notifica, a través de la generación del ReceiveCompleted evento, cuando llega un mensaje a la cola. A MessageQueue continuación, puede acceder al mensaje llamando EndReceive(IAsyncResult) o recuperando el resultado mediante ReceiveCompletedEventArgs.

El BeginReceive método devuelve inmediatamente, pero la operación asincrónica no se completa hasta que se llama al controlador de eventos.

Dado BeginReceive que es asincrónico, puede llamarlo para recibir un mensaje de la cola sin bloquear el subproceso actual de ejecución. Para recibir un mensaje de forma sincrónica, use el Receive método .

Una vez completada una operación asincrónica, puede llamar o BeginReceive volver a llamar BeginPeek al controlador de eventos para seguir recibiendo notificaciones.

Si CanRead es false, se genera el evento de finalización, pero se producirá una excepción al llamar a EndReceive(IAsyncResult).

que IAsyncResultBeginReceive devuelve identifica la operación asincrónica que inició el método. Puede usarlo IAsyncResult durante toda la duración de la operación, aunque generalmente no lo use hasta EndReceive(IAsyncResult) que se llame a . Sin embargo, si inicia varias operaciones asincrónicas, puede colocar sus IAsyncResult valores en una matriz y especificar si se debe esperar a que se completen todas las operaciones o cualquier operación. En este caso, se usa la AsyncWaitHandle propiedad de IAsyncResult para identificar la operación completada.

Esta sobrecarga especifica un tiempo de espera. Si el intervalo especificado por el timeout parámetro expira, este componente genera el ReceiveCompleted evento . Dado que no existe ningún mensaje, una llamada posterior a EndReceive(IAsyncResult) producirá una excepción.

No use la llamada BeginReceive asincrónica con transacciones. Si desea realizar una operación asincrónica transaccional, llame BeginPeeka y coloque la transacción y el método (sincrónico) Receive dentro del controlador de eventos que cree para la operación de inspección. El controlador de eventos puede contener funcionalidad como se muestra en el siguiente código de C#.

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

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

BeginReceive(TimeSpan, Object)

Inicia una operación de recepción asincrónica con un tiempo de espera y un objeto de estado específicos, lo que proporciona información relacionada durante toda la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject);
public IAsyncResult BeginReceive (TimeSpan timeout, object stateObject);
member this.BeginReceive : TimeSpan * obj -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan, stateObject As Object) As IAsyncResult

Parámetros

timeout
TimeSpan

TimeSpan que indica el intervalo de tiempo que hay que esperar a que haya un mensaje disponible.

stateObject
Object

Objeto de estado, especificado por la aplicación, que contiene información asociada a la operación asincrónica.

Devoluciones

IAsyncResult

IAsyncResult que identifica la solicitud asincrónica publicada.

Excepciones

ArgumentException

El valor especificado para el parámetro timeout no es válido.

MessageQueueException

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

Ejemplos

En el ejemplo de código siguiente se crea una operación de recepción asincrónica. El ejemplo de código crea un controlador de eventos, MyReceiveCompleted, y lo adjunta al delegado del ReceiveCompleted controlador de eventos. El ejemplo de código envía un mensaje a una cola de mensajes local y, a continuación, llama a BeginReceive(TimeSpan, Object), pasando un valor de tiempo de espera de diez segundos y un entero único que identifica ese mensaje determinado. Cuando se genera un ReceiveCompleted evento, el controlador de eventos recibe el mensaje y escribe el cuerpo del mensaje y el identificador de mensaje entero en la pantalla.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", e->AsyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;

    // Represents a state object associated with each message.
    int messageNumber = 0;

    try
    {
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}


using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
            ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}",
            (int)asyncResult.AsyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Comentarios

En el procesamiento asincrónico, se usa BeginReceive para generar el ReceiveCompleted evento cuando un mensaje esté disponible en la cola o cuando haya expirado el intervalo de tiempo especificado.

ReceiveCompleted también se genera si ya existe un mensaje en la cola.

Use esta sobrecarga para asociar información a la operación que se conservará durante toda la duración de la operación. El controlador de eventos puede detectar esta información examinando la AsyncState propiedad de que IAsyncResult está asociada a la operación.

Para usar BeginReceive, cree un controlador de eventos que procese los resultados de la operación asincrónica y asócielo al delegado de eventos. BeginReceive inicia una operación de recepción asincrónica; MessageQueue se notifica, a través de la generación del ReceiveCompleted evento, cuando llega un mensaje a la cola. A MessageQueue continuación, puede acceder al mensaje llamando EndReceive(IAsyncResult) a o recuperando el resultado mediante ReceiveCompletedEventArgs.

El BeginReceive método devuelve inmediatamente, pero la operación asincrónica no se completa hasta que se llama al controlador de eventos.

Dado BeginReceive que es asincrónico, puede llamarlo para recibir un mensaje de la cola sin bloquear el subproceso actual de ejecución. Para recibir un mensaje de forma sincrónica, use el Receive método .

Una vez completada una operación asincrónica, puede llamar o BeginReceive volver a llamar BeginPeek al controlador de eventos para seguir recibiendo notificaciones.

IAsyncResult que BeginReceive devuelve identifica la operación asincrónica que inició el método. Puede usarlo IAsyncResult durante toda la vigencia de la operación, aunque por lo general no lo use hasta EndReceive(IAsyncResult) que se llame a . Sin embargo, si inicia varias operaciones asincrónicas, puede colocar sus IAsyncResult valores en una matriz y especificar si desea esperar a que se completen todas las operaciones o cualquier operación. En este caso, se usa la AsyncWaitHandle propiedad de IAsyncResult para identificar la operación completada.

Esta sobrecarga especifica un tiempo de espera y un objeto de estado. Si el intervalo especificado por el timeout parámetro expira, este componente genera el ReceiveCompleted evento. Dado que no existe ningún mensaje, una llamada posterior a EndReceive(IAsyncResult) producirá una excepción.

El objeto de estado asocia información de estado a la operación. Por ejemplo, si llama BeginReceive varias veces para iniciar varias operaciones, puede identificar cada operación a través de un objeto de estado independiente que defina.

También puede usar el objeto de estado para pasar información a través de subprocesos de proceso. Si se inicia un subproceso pero la devolución de llamada está en un subproceso diferente en un escenario asincrónico, el objeto de estado se serializa y se pasa de nuevo junto con la información del evento.

No use la llamada BeginReceive asincrónica con transacciones. Si desea realizar una operación asincrónica transaccional, llame a BeginPeeky coloque la transacción y el método (sincrónico) Receive en el controlador de eventos que cree para la operación de inspección. El controlador de eventos puede contener funcionalidad como se muestra en el código de C# siguiente.

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

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

BeginReceive(TimeSpan, Object, AsyncCallback)

Inicia una operación de recepción asincrónica con un tiempo de espera y un objeto de estado específicos, lo que proporciona información relacionada durante toda la operación. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);
public IAsyncResult BeginReceive (TimeSpan timeout, object stateObject, AsyncCallback callback);
member this.BeginReceive : TimeSpan * obj * AsyncCallback -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan, stateObject As Object, callback As AsyncCallback) As IAsyncResult

Parámetros

timeout
TimeSpan

TimeSpan que indica el intervalo de tiempo que hay que esperar a que haya un mensaje disponible.

stateObject
Object

Objeto de estado, especificado por la aplicación, que contiene información asociada a la operación asincrónica.

callback
AsyncCallback

AsyncCallback que recibirá la notificación de finalización de la operación asincrónica.

Devoluciones

IAsyncResult

IAsyncResult que identifica la solicitud asincrónica publicada.

Excepciones

ArgumentException

El valor especificado para el parámetro timeout no es válido.

MessageQueueException

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

Ejemplos

En el ejemplo de código siguiente se crea una operación de recepción asincrónica. El ejemplo de código envía un mensaje a una cola de mensajes local y, a continuación, llama a BeginReceive(TimeSpan, Object, AsyncCallback), pasando: un valor de tiempo de espera de diez segundos; un entero único que identifica ese mensaje determinado; y una nueva instancia de que identifica el controlador de AsyncCallback eventos, MyReceiveCompleted. Cuando se genera un ReceiveCompleted evento, el controlador de eventos recibe el mensaje y escribe el cuerpo del mensaje y el identificador de mensaje entero en la pantalla.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if (!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(IAsyncResult^ asyncResult)
{
    // Connect to the queue.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(asyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", asyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Represents a state object associated with each message.
    int messageNumber = 0;

    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

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

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++,
            gcnew AsyncCallback(HandleReceiveCompleted));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}


using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

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

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++,
            new AsyncCallback(MyReceiveCompleted));
            
        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(IAsyncResult asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}", (int)asyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Comentarios

Cuando se usa esta sobrecarga, la devolución de llamada especificada en el parámetro de devolución de llamada se invoca directamente cuando un mensaje está disponible en la cola o cuando el intervalo de tiempo especificado ha expirado; el ReceiveCompleted evento no se genera. Las demás sobrecargas de BeginReceive se basan en este componente para generar el ReceiveCompleted evento.

ReceiveCompleted también se genera si ya existe un mensaje en la cola.

Para usar BeginReceive, cree un controlador de eventos que procese los resultados de la operación asincrónica y asócielo al delegado de eventos. BeginReceive inicia una operación de recepción asincrónica; MessageQueue se notifica, a través de la generación del ReceiveCompleted evento, cuando llega un mensaje a la cola. A MessageQueue continuación, puede acceder al mensaje llamando EndReceive(IAsyncResult) a o recuperando el resultado mediante ReceiveCompletedEventArgs.

El BeginReceive método devuelve inmediatamente, pero la operación asincrónica no se completa hasta que se llama al controlador de eventos.

Dado BeginReceive que es asincrónico, puede llamarlo para recibir un mensaje de la cola sin bloquear el subproceso actual de ejecución. Para recibir un mensaje de forma sincrónica, use el Receive método .

Una vez completada una operación asincrónica, puede llamar o BeginReceive volver a llamar BeginPeek al controlador de eventos para seguir recibiendo notificaciones.

IAsyncResult que BeginReceive devuelve identifica la operación asincrónica que inició el método. Puede usarlo IAsyncResult durante toda la vigencia de la operación, aunque por lo general no lo use hasta EndReceive(IAsyncResult) que se llame a . Sin embargo, si inicia varias operaciones asincrónicas, puede colocar sus IAsyncResult valores en una matriz y especificar si desea esperar a que se completen todas las operaciones o cualquier operación. En este caso, se usa la AsyncWaitHandle propiedad de IAsyncResult para identificar la operación completada.

El objeto de estado asocia información de estado a la operación. Por ejemplo, si llama BeginReceive varias veces para iniciar varias operaciones, puede identificar cada operación a través de un objeto de estado independiente que defina.

También puede usar el objeto de estado para pasar información a través de subprocesos de proceso. Si se inicia un subproceso pero la devolución de llamada está en un subproceso diferente en un escenario asincrónico, el objeto de estado se serializa y se pasa de nuevo junto con la información del evento.

No use la llamada BeginReceive asincrónica con transacciones. Si desea realizar una operación asincrónica transaccional, llame a BeginPeeky coloque la transacción y el método (sincrónico) Receive en el controlador de eventos que cree para la operación de inspección. El controlador de eventos puede contener funcionalidad como se muestra en el código de C# siguiente.

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

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

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Inicia una operación de recepción asincrónica que tiene especificado un tiempo de espera y utiliza un cursor y un objeto de estado especificados. El objeto de estado proporciona la información asociada a lo largo del período de duración de la operación. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Object ^ state, AsyncCallback ^ callback);
public IAsyncResult BeginReceive (TimeSpan timeout, System.Messaging.Cursor cursor, object state, AsyncCallback callback);
member this.BeginReceive : TimeSpan * System.Messaging.Cursor * obj * AsyncCallback -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan, cursor As Cursor, state As Object, callback As AsyncCallback) As IAsyncResult

Parámetros

timeout
TimeSpan

TimeSpan que indica el intervalo de tiempo que hay que esperar a que haya un mensaje disponible.

cursor
Cursor

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

state
Object

Objeto de estado, especificado por la aplicación, que contiene información asociada a la operación asincrónica.

callback
AsyncCallback

El objeto AsyncCallback que recibe la notificación de finalización de la operación asincrónica.

Devoluciones

IAsyncResult

IAsyncResult que identifica la solicitud asincrónica publicada.

Excepciones

ArgumentNullException

El parámetro cursor es null.

ArgumentException

El valor especificado para el parámetro timeout no es válido.

MessageQueueException

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

Comentarios

Cuando se usa esta sobrecarga, la devolución de llamada especificada en el parámetro callback se invoca directamente cuando un mensaje está disponible en la cola o cuando el intervalo de tiempo especificado ha expirado; el ReceiveCompleted evento no se genera. Las demás sobrecargas de BeginReceive se basan en este componente para generar el ReceiveCompleted evento.

ReceiveCompleted también se genera si ya existe un mensaje en la cola.

Para usar BeginReceive, cree un controlador de eventos que procese los resultados de la operación asincrónica y asócielo con el delegado de eventos. BeginReceive inicia una operación de recepción asincrónica; MessageQueue se notifica, a través de la generación del ReceiveCompleted evento, cuando llega un mensaje a la cola. A MessageQueue continuación, puede acceder al mensaje llamando EndReceive(IAsyncResult) o recuperando el resultado mediante ReceiveCompletedEventArgs.

El BeginReceive método devuelve inmediatamente, pero la operación asincrónica no se completa hasta que se llama al controlador de eventos.

Dado BeginReceive que es asincrónico, puede llamarlo para recibir un mensaje de la cola sin bloquear el subproceso actual de ejecución. Para recibir un mensaje de forma sincrónica, use el Receive método .

Una vez completada una operación asincrónica, puede llamar o BeginReceive volver a llamar BeginPeek al controlador de eventos para seguir recibiendo notificaciones.

que IAsyncResultBeginReceive devuelve identifica la operación asincrónica que inició el método. Puede usarlo IAsyncResult durante toda la duración de la operación, aunque generalmente no lo use hasta EndReceive(IAsyncResult) que se llame a . Sin embargo, si inicia varias operaciones asincrónicas, puede colocar sus IAsyncResult valores en una matriz y especificar si se debe esperar a que se completen todas las operaciones o cualquier operación. En este caso, use la AsyncWaitHandle propiedad de IAsyncResult para identificar la operación completada.

El objeto de estado asocia información de estado a la operación. Por ejemplo, si llama varias BeginReceive veces a para iniciar varias operaciones, puede identificar cada operación a través de un objeto de estado independiente que defina.

También puede usar el objeto de estado para pasar información a través de subprocesos de proceso. Si se inicia un subproceso pero la devolución de llamada está en otro subproceso en un escenario asincrónico, el objeto de estado se serializa y se devuelve junto con la información del evento.

No use la llamada BeginReceive asincrónica con transacciones. Si desea realizar una operación asincrónica transaccional, llame BeginPeeka y coloque la transacción y el método (sincrónico) Receive dentro del controlador de eventos que cree para la operación de inspección. El controlador de eventos puede contener funcionalidad como se muestra en el siguiente código de C#.

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

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.