Compartir a través de

MessageQueue.BeginPeek Método

  • Referencia

Definición

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

Inicia una operación de búsqueda peek asincrónica al indicar a Message Queuing que empiece a leer un mensaje y que lo notifique al controlador de eventos cuando haya terminado.

Sobrecargas

BeginPeek(TimeSpan, Object, AsyncCallback)

Inicia una operación de búsqueda peek 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.
BeginPeek(TimeSpan, Object)

Inicia una operación de búsqueda peek 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.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Inicia una operación de búsqueda peek asincrónica que tiene especificado un tiempo de espera y utiliza un cursor, una acción de búsqueda peek 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.
BeginPeek()

Inicia una operación de ver el código sin salir asincrónica sin tiempo de espera. La operación no se completa hasta que hay un mensaje disponible en la cola.
BeginPeek(TimeSpan)

Inicia una operación de ver el código sin salir asincrónica con 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.

BeginPeek(TimeSpan, Object, AsyncCallback)

Inicia una operación de búsqueda peek 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 ^ 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

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 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 inspeccionar la cola sin bloquear el subproceso actual de ejecución. Para inspeccionar la cola de forma sincrónica, 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 que inició el método. Puede usarlo IAsyncResult durante toda la duración 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 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.

El objeto de estado asocia información de estado a la operación. Por ejemplo, si llama varias BeginPeek veces a 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)

Inicia una operación de búsqueda peek 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 ^ 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

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 inspección asincrónica mediante la ruta de acceso de cola ".\myQueue". Crea un controlador de eventos, MyPeekCompletedy 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 en particular. Cuando se genera un PeekCompleted evento o se agota el tiempo de espera expirado, se recupera el mensaje, si existe, 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 el intervalo de tiempo especificado ha expirado.

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 tener acceso 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. A MessageQueue 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 inspeccionar la cola sin bloquear el subproceso actual de ejecución. Para inspeccionar la cola de forma sincrónica, 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 que inició el método. Puede usarlo IAsyncResult durante toda la duración 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 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 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.

El objeto de estado asocia información de estado a la operación. Por ejemplo, si llama varias BeginPeek veces a para iniciar varias operaciones, puede identificar cada operación a través de un objeto de estado independiente que defina. Para obtener una ilustración de este escenario, consulte la sección Ejemplo.

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.

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 búsqueda peek asincrónica que tiene especificado un tiempo de espera y utiliza un cursor, una acción de búsqueda peek 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 ^ 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

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.

action
PeekAction

Uno de los valores de PeekAction. Indica si se ejecuta el método peek en el mensaje actual de la cola o en el mensaje siguiente.

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

ArgumentOutOfRangeException

Se especificó un valor distinto de PeekAction.Current o PeekAction.Next para el parámetro action.

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 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 inspeccionar la cola sin bloquear el subproceso actual de ejecución. Para inspeccionar la cola de forma sincrónica, 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 duración 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 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 BeginPeek veces a 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()

Inicia una operación de ver el código sin salir asincrónica sin tiempo de espera. La operación no se completa hasta que hay un mensaje 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 obtener acceso a un método de 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 busca el mensaje y escribe su cuerpo en la pantalla. A continuación, se llama BeginPeek de nuevo al ejemplo 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.

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. A MessageQueue 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 inspeccionar la cola sin bloquear el subproceso actual de ejecución. Para inspeccionar la cola de forma sincrónica, 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 IAsyncResultBeginPeek 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 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 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 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 ver el código sin salir asincrónica con 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 ^ 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

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.

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 inspección asincrónica mediante la ruta de acceso de cola ".\myQueue". Crea un controlador de eventos, MyPeekCompletedy 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 el intervalo de tiempo especificado ha expirado.

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

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. A MessageQueue 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 inspeccionar la cola sin bloquear el subproceso actual de ejecución. Para inspeccionar la cola de forma sincrónica, 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 IAsyncResultBeginPeek 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 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 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 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.