MessageQueue.BeginPeek Método

Definición

Espacio de nombres:: System.Messaging

Ensamblado:: System.Messaging.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Inicia una operación de inspección asincrónica indicando a Message Queuing que empiece a examinar un mensaje y notificar al controlador de eventos cuando termine.

Sobrecargas

Nombre	Description
BeginPeek(TimeSpan, Object, AsyncCallback)	Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado y un objeto de estado especificado, que proporciona información asociada durante toda la duración de la operación. Esta sobrecarga recibe una notificación, a través de una devolución de llamada, de la identidad del controlador de eventos para la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginPeek(TimeSpan, Object)	Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado y un objeto de estado especificado, que proporciona información asociada durante toda la duración de la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado y que usa un cursor especificado, una acción de inspección especificada y un objeto de estado especificado. El objeto de estado proporciona información asociada durante toda la vigencia de la operación. Esta sobrecarga recibe una notificación, a través de una devolución de llamada, de la identidad del controlador de eventos para la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginPeek()	Inicia una operación de inspección asincrónica que no tiene tiempo de espera. La operación no se completa hasta que un mensaje esté disponible en la cola.
BeginPeek(TimeSpan)	Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.

BeginPeek(TimeSpan, Object, AsyncCallback)

Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado y un objeto de estado especificado, que proporciona información asociada durante toda la duración de la operación. Esta sobrecarga recibe una notificación, a través de una devolución de llamada, de la identidad del controlador de eventos para la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);

public IAsyncResult BeginPeek(TimeSpan timeout, object stateObject, AsyncCallback callback);

member this.BeginPeek : TimeSpan * obj * AsyncCallback -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan, stateObject As Object, callback As AsyncCallback) As IAsyncResult

Parámetros

timeout: TimeSpan

que TimeSpan indica el intervalo de tiempo para esperar a que un mensaje esté disponible.

stateObject: Object

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

callback: AsyncCallback

que AsyncCallback recibirá la notificación de la 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 acceder a un método Message Queuing.

Ejemplos

En el ejemplo de código siguiente se crea una operación de inspección asincrónica. El ejemplo de código envía un mensaje a una cola de mensajes local y, a continuación, llama a BeginPeek(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, MyPeekCompleted. Cuando se genera un PeekCompleted evento, el controlador de eventos examina 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 PeekCompleted event.
void MyPeekCompleted(IAsyncResult^ asyncResult)
{
    // Connect to the queue.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

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

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

    // Receive the message. This will remove the message from the queue.
    msg = queue->Receive(TimeSpan::FromSeconds(10.0));

    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.
    CreateQueue(".\\exampleQueue", false);

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

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

    // Begin the asynchronous peek operation.
    queue->BeginPeek(TimeSpan::FromSeconds(10.0), messageNumber++,
        gcnew AsyncCallback(MyPeekCompleted));

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

    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 peek operation.
        queue.BeginPeek(TimeSpan.FromSeconds(10.0), messageNumber++,
            new AsyncCallback(MyPeekCompleted));

        // 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 PeekCompleted event.
    private static void MyPeekCompleted(IAsyncResult asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // End the asynchronous peek operation.
        Message msg = queue.EndPeek(asyncResult);

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

        // Receive the message. This will remove the message from the queue.
        msg = queue.Receive(TimeSpan.FromSeconds(10.0));
    }
}

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 PeekCompleted evento no se genera. Las demás sobrecargas de BeginPeek se basan en este componente para generar el PeekCompleted evento.

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

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

Dado BeginPeek que es asincrónico, puede llamarlo para ver la cola sin bloquear el subproceso actual de ejecución. Para examinar de forma sincrónica la cola, use el Peek 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.

BeginPeek devuelve un IAsyncResult que identifica la operación asincrónica que inició el método. Puede usarlo IAsyncResult durante toda la vigencia de la operación, aunque generalmente no lo use hasta EndPeek(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 varias BeginPeek veces para iniciar varias operaciones, puede identificar cada operación a través de un objeto de estado independiente que defina.

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

BeginPeek(TimeSpan, Object)

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout, System::Object ^ stateObject);

public IAsyncResult BeginPeek(TimeSpan timeout, object stateObject);

member this.BeginPeek : TimeSpan * obj -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan, stateObject As Object) As IAsyncResult

Parámetros

timeout: TimeSpan

que TimeSpan indica el intervalo de tiempo para esperar a que un mensaje esté 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 acceder a un método Message Queuing.

Ejemplos

En el ejemplo de código siguiente se crea una operación de inspección asincrónica mediante la ruta de acceso de cola ".\myQueue". Crea un controlador de eventos, MyPeekCompleted, y lo adjunta al delegado del PeekCompleted controlador de eventos. BeginPeek se llama a , con un tiempo de espera de un minuto. Cada llamada a BeginPeek tiene un entero asociado único que identifica esa operación determinada. Cuando se genera un PeekCompleted evento o ha expirado el tiempo de espera, el mensaje, si existe, se recupera y su cuerpo y el identificador entero específico de la operación se escriben en la pantalla. A continuación BeginPeek , se llama de nuevo para iniciar una nueva operación de inspección asincrónica con el mismo tiempo de espera y el entero asociado de la operación recién completada.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

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

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

         // End the asynchronous peek operation.
         Message^ m = mq->EndPeek( asyncResult->AsyncResult );

         // Display message information on the screen, 
         // including the message number (state object).
         Console::WriteLine( "Message: {0} {1}", asyncResult->AsyncResult->AsyncState, static_cast<String^>(m->Body) );

         // Restart the asynchronous peek operation, with the 
         // same time-out.
         mq->BeginPeek( TimeSpan(0,1,0), messageNumber++ );
      }
      catch ( MessageQueueException^ e ) 
      {
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( e );
         }

         // Handle other sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};


// Provides an entry point into the application.
//         
// This example performs asynchronous peek 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 PeekCompleted event.
   myQueue->PeekCompleted += gcnew PeekCompletedEventHandler( MyNewQueue::MyPeekCompleted );

   // Begin the asynchronous peek operation with a timeout 
   // of one minute.
   myQueue->BeginPeek( TimeSpan(0,1,0), MyNewQueue::messageNumber++ );

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

using System;
using System.Messaging;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue3
    {
        // Represents a state object associated with each message.
        static int messageNumber = 0;

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous peek 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 PeekCompleted event.
            myQueue.PeekCompleted += new
                PeekCompletedEventHandler(MyPeekCompleted);

            // Begin the asynchronous peek operation with a time-out
            // of one minute.
            myQueue.BeginPeek(new TimeSpan(0, 1, 0), messageNumber++);

            // Do other work on the current thread.

            return;
        }

        //**************************************************
        // Provides an event handler for the PeekCompleted
        // event.
        //**************************************************

        private static void MyPeekCompleted(Object source,
            PeekCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous peek operation.
                Message m = mq.EndPeek(asyncResult.AsyncResult);

                // Display message information on the screen,
                // including the message number (state object).
                Console.WriteLine("Message: " +
                    (int)asyncResult.AsyncResult.AsyncState + " "
                    + (string)m.Body);

                // Restart the asynchronous peek operation, with the
                // same time-out.
                mq.BeginPeek(new TimeSpan(0, 1, 0), messageNumber++);
            }

            catch (MessageQueueException e)
            {
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine(e.ToString());
                }

                // Handle other sources of MessageQueueException.
            }

            // Handle other exceptions.

            return;
        }
    }
}

Imports System.Messaging


   
' Provides a container class for the example.

Public Class MyNewQueue

        ' Represents a state object associated with each message.
        Private Shared messageNumber As Integer = 0



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous peek 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 PeekCompleted event.
            AddHandler myQueue.PeekCompleted, AddressOf _
                MyPeekCompleted

            ' Begin the asynchronous peek operation with a time-out 
            ' of one minute.
            myQueue.BeginPeek(New TimeSpan(0, 1, 0), messageNumber)
            messageNumber += 1

            ' Do other work on the current thread.
            Return
        End Sub



        ' Provides an event handler for the PeekCompleted
        ' event.


        Private Shared Sub MyPeekCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As _
            PeekCompletedEventArgs)

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

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

                ' Display message information on the screen, 
                ' including(the) message number (state object).
                Console.WriteLine(("Message: " + _
                    CInt(asyncResult.AsyncResult.AsyncState) + _
                    " " + CStr(m.Body)))

                ' Restart the asynchronous peek operation, with the 
                ' same time-out.
                mq.BeginPeek(New TimeSpan(0, 1, 0), messageNumber)
                messageNumber += 1


            Catch e As MessageQueueException

                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    Console.WriteLine(e.ToString())

                    ' Handle other sources of MessageQueueException.

                End If

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Comentarios

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

PeekCompleted 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 acceder a esta información examinando la AsyncState propiedad de que IAsyncResult está asociada a la operación.

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

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

Dado BeginPeek que es asincrónico, puede llamarlo para ver la cola sin bloquear el subproceso actual de ejecución. Para examinar de forma sincrónica la cola, use el Peek 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.

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 PeekCompleted evento. Dado que no existe ningún mensaje, una llamada posterior a EndPeek(IAsyncResult) producirá una excepción.

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.

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

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

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado y que usa un cursor especificado, una acción de inspección especificada y un objeto de estado especificado. El objeto de estado proporciona información asociada durante toda la vigencia de la operación. Esta sobrecarga recibe una notificación, a través de una devolución de llamada, de la identidad del controlador de eventos para la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::PeekAction action, System::Object ^ state, AsyncCallback ^ callback);

public IAsyncResult BeginPeek(TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.PeekAction action, object state, AsyncCallback callback);

member this.BeginPeek : TimeSpan * System.Messaging.Cursor * System.Messaging.PeekAction * obj * AsyncCallback -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan, cursor As Cursor, action As PeekAction, state As Object, callback As AsyncCallback) As IAsyncResult

Parámetros

timeout: TimeSpan

que TimeSpan indica el intervalo de tiempo para esperar a que un mensaje esté disponible.

cursor: Cursor

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

action: PeekAction

Uno de los PeekAction valores. Indica si se va a ver el mensaje actual en la cola o el siguiente mensaje.

state: Object

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

callback: AsyncCallback

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

Devoluciones

IAsyncResult

IAsyncResult que identifica la solicitud asincrónica publicada.

Excepciones

ArgumentOutOfRangeException

Valor distinto de PeekAction.Current o PeekAction.Next especificado para el action parámetro .

ArgumentNullException

El cursor parámetro es null.

ArgumentException

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

MessageQueueException

Error al acceder a un método 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 PeekCompleted evento no se genera. Las demás sobrecargas de BeginPeek se basan en este componente para generar el PeekCompleted evento.

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

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

Dado BeginPeek que es asincrónico, puede llamarlo para ver la cola sin bloquear el subproceso actual de ejecución. Para examinar de forma sincrónica la cola, use el Peek 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.

BeginPeek devuelve un IAsyncResult objeto que identifica la operación asincrónica iniciada por el método . Puede usarlo IAsyncResult durante toda la vigencia de la operación, aunque generalmente no lo use hasta EndPeek(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, use la AsyncWaitHandle propiedad de IAsyncResult para identificar la operación completada.

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

BeginPeek()

Inicia una operación de inspección asincrónica que no tiene tiempo de espera. La operación no se completa hasta que un mensaje esté disponible en la cola.

public:
 IAsyncResult ^ BeginPeek();

public IAsyncResult BeginPeek();

member this.BeginPeek : unit -> IAsyncResult

Public Function BeginPeek () As IAsyncResult

Devoluciones

IAsyncResult

IAsyncResult que identifica la solicitud asincrónica publicada.

Excepciones

MessageQueueException

Error al acceder a un método Message Queuing.

Ejemplos

En el ejemplo de código siguiente se crea un controlador de eventos denominado MyPeekCompleted, se adjunta al delegado del PeekCompleted controlador de eventos y se llama BeginPeek a para iniciar una operación de inspección asincrónica en la cola que se encuentra en la ruta de acceso ".\myQueue". Cuando se genera un PeekCompleted evento, el ejemplo muestra el mensaje y escribe su cuerpo en la pantalla. A continuación, el ejemplo llama BeginPeek de nuevo para iniciar una nueva operación de inspección asincrónica.

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

using namespace System;
using namespace System::Messaging;

// This example performs asynchronous peek operation
// processing.
//*************************************************
ref class MyNewQueue
{
public:

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

      // End the asynchronous peek operation.
      Message^ m = mq->EndPeek( asyncResult->AsyncResult );

      // Display message information on the screen.
      Console::WriteLine( "Message: {0}", static_cast<String^>(m->Body) );

      // Restart the asynchronous peek operation.
      mq->BeginPeek();
      return;
   }
};

// Provides an entry point into the application.
//         
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 PeekCompleted event.
   myQueue->PeekCompleted += gcnew PeekCompletedEventHandler( MyNewQueue::MyPeekCompleted );

   // Begin the asynchronous peek operation.
   myQueue->BeginPeek();

   // Do other work on the current thread.
   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 performs asynchronous peek 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 PeekCompleted event.
            myQueue.PeekCompleted += new
                PeekCompletedEventHandler(MyPeekCompleted);

            // Begin the asynchronous peek operation.
            myQueue.BeginPeek();

            // Do other work on the current thread.

            return;
        }

        //**************************************************
        // Provides an event handler for the PeekCompleted
        // event.
        //**************************************************

        private static void MyPeekCompleted(Object source,
            PeekCompletedEventArgs asyncResult)
        {
            // Connect to the queue.
            MessageQueue mq = (MessageQueue)source;

            // End the asynchronous peek operation.
            Message m = mq.EndPeek(asyncResult.AsyncResult);

            // Display message information on the screen.
            Console.WriteLine("Message: " + (string)m.Body);

            // Restart the asynchronous peek operation.
            mq.BeginPeek();

            return;
        }
    }
}

Imports System.Messaging





' Provides a container class for the example.
Public Class MyNewQueue



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous peek 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 PeekCompleted event.
            AddHandler myQueue.PeekCompleted, AddressOf _
                MyPeekCompleted

            ' Begin the asynchronous peek operation.
            myQueue.BeginPeek()

            ' Do other work on the current thread.
            Return
        End Sub


        '**************************************************
        ' Provides an event handler for the PeekCompleted
        ' event.
        '**************************************************

        Private Shared Sub MyPeekCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As PeekCompletedEventArgs)

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

            ' End the asynchronous peek operation.
            Dim m As Message = mq.EndPeek(asyncResult.AsyncResult)

            ' Display message information on the screen.
            Console.WriteLine(("Message: " + CStr(m.Body)))

            ' Restart the asynchronous peek operation.
            mq.BeginPeek()

            Return

        End Sub

End Class

Comentarios

En el procesamiento asincrónico, se usa BeginPeek para generar el PeekCompleted evento cuando un mensaje está disponible en la cola.

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

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

Dado BeginPeek que es asincrónico, puede llamarlo para ver la cola sin bloquear el subproceso actual de ejecución. Para examinar de forma sincrónica la cola, use el Peek 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 IAsyncResult BeginPeek devuelve identifica la operación asincrónica que inició el método. Puede usarlo IAsyncResult durante toda la vigencia de la operación, aunque generalmente no lo use hasta EndPeek(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.

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

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

BeginPeek(TimeSpan)

Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout);

public IAsyncResult BeginPeek(TimeSpan timeout);

member this.BeginPeek : TimeSpan -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan) As IAsyncResult

Parámetros

timeout: TimeSpan

que TimeSpan indica el intervalo de tiempo para esperar a que un mensaje esté 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.

MessageQueueException

Error al acceder a un método Message Queuing.

Ejemplos

En el ejemplo de código siguiente se crea una operación de inspección asincrónica mediante la ruta de acceso de cola ".\myQueue". Crea un controlador de eventos, MyPeekCompleted, y lo adjunta al delegado del PeekCompleted controlador de eventos. BeginPeek se llama a con un tiempo de espera de un minuto para iniciar la operación de inspección asincrónica. Cuando se genera un PeekCompleted evento o expira el tiempo de espera, el mensaje se recupera si existe y su cuerpo se escribe en la pantalla. A continuación BeginPeek , se llama de nuevo para iniciar una nueva operación de inspección asincrónica con el mismo tiempo de espera.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
   static void MyPeekCompleted( Object^ source, PeekCompletedEventArgs^ asyncResult )
   {      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous peek operation.
         Message^ m = mq->EndPeek( asyncResult->AsyncResult );

         // Display message information on the screen.
         Console::WriteLine( "Message: {0}", static_cast<String^>(m->Body) );

         // Restart the asynchronous peek operation, with the 
         // same time-out.
         mq->BeginPeek( TimeSpan(0,1,0) );
      }
      catch ( MessageQueueException^ e ) 
      {
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( e );
         }

         // Handle other sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};

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 PeekCompleted event.
   myQueue->PeekCompleted += gcnew PeekCompletedEventHandler( MyNewQueue::MyPeekCompleted );

   // Begin the asynchronous peek operation with a timeout 
   // of one minute.
   myQueue->BeginPeek( TimeSpan(0,1,0) );

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

using System;
using System.Messaging;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue2
    {
        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous peek 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 PeekCompleted event.
            myQueue.PeekCompleted += new
                PeekCompletedEventHandler(MyPeekCompleted);

            // Begin the asynchronous peek operation with a time-out
            // of one minute.
            myQueue.BeginPeek(new TimeSpan(0, 1, 0));

            // Do other work on the current thread.

            return;
        }

        //**************************************************
        // Provides an event handler for the PeekCompleted
        // event.
        //**************************************************

        private static void MyPeekCompleted(Object source,
            PeekCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous peek operation.
                Message m = mq.EndPeek(asyncResult.AsyncResult);

                // Display message information on the screen.
                Console.WriteLine("Message: " + (string)m.Body);

                // Restart the asynchronous peek operation, with the
                // same time-out.
                mq.BeginPeek(new TimeSpan(0, 1, 0));
            }

            catch (MessageQueueException e)
            {
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine(e.ToString());
                }

                // Handle other sources of MessageQueueException.
            }

            // Handle other exceptions.

            return;
        }
    }
}

Imports System.Messaging


' Provides a container class for the example.
Public Class MyNewQueue



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous peek 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 PeekCompleted event.
            AddHandler myQueue.PeekCompleted, _
                    AddressOf MyPeekCompleted

            ' Begin the asynchronous peek operation with a time-out 
            ' of one minute.
            myQueue.BeginPeek(New TimeSpan(0, 1, 0))

            ' Do other work on the current thread.
            Return

        End Sub



        ' Provides an event handler for the PeekCompleted
        ' event.


        Private Shared Sub MyPeekCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As _
            PeekCompletedEventArgs)

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

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

                ' Display message information on the screen.
                Console.WriteLine(("Message: " + CStr(m.Body)))

                ' Restart the asynchronous peek operation, with the 
                ' same time-out.
                mq.BeginPeek(New TimeSpan(0, 1, 0))

            Catch e As MessageQueueException

                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    Console.WriteLine(e.ToString())

                    ' Handle other sources of MessageQueueException.
                End If

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Comentarios

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

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

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

Dado BeginPeek que es asincrónico, puede llamarlo para ver la cola sin bloquear el subproceso actual de ejecución. Para examinar de forma sincrónica la cola, use el Peek 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.

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

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

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.

Comentarios

Resultoulle útil esta páxina?

Compartir por

MessageQueue.BeginPeek Método

Definición

Sobrecargas

BeginPeek(TimeSpan, Object, AsyncCallback)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

BeginPeek(TimeSpan, Object)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

BeginPeek()

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

BeginPeek(TimeSpan)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Seguridad para subprocesos

Comentarios