MessageQueue.BeginPeek Método

Referência

Definição

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Inicia uma operação de espiada assíncrona informando o Enfileiramento de Mensagens para começar a espiar uma mensagem e notificar o manipulador de eventos quando terminar.

Sobrecargas

BeginPeek(TimeSpan, Object, AsyncCallback)	Inicia uma operação assíncrona de espiada que tem um tempo limite especificado e um objeto de estado especificado, que fornece informações associadas durante todo o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.
BeginPeek(TimeSpan, Object)	Inicia uma operação assíncrona de espiada que tem um tempo limite especificado e um objeto de estado especificado, que fornece informações associadas durante todo o tempo de vida da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Inicia uma operação de espiada assíncrona que tem um tempo limite especificado e usa um cursor específico, uma ação de espiada especificada e um objeto de estado especificado. O objeto de estado fornece informações associadas em todo o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.
BeginPeek()	Inicia uma operação de espiada assíncrona que não tem um tempo limite. A operação não será concluída até que uma mensagem fique disponível na fila.
BeginPeek(TimeSpan)	Inicia uma operação de espiada assíncrona que tem um tempo limite especificado. A operação não será concluída até que uma mensagem fique disponível na fila ou que ocorra o tempo limite.

BeginPeek(TimeSpan, Object, AsyncCallback)

Inicia uma operação assíncrona de espiada que tem um tempo limite especificado e um objeto de estado especificado, que fornece informações associadas durante todo o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.

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

Um TimeSpan que indica o intervalo de tempo para aguardar uma mensagem se tornar disponível.

stateObject: Object

Um objeto de estado, especificado pelo aplicativo, que contém informações associadas à operação assíncrona.

callback: AsyncCallback

O AsyncCallback que receberá a notificação da conclusão da operação assíncrona.

Retornos

IAsyncResult

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Exemplos

O exemplo de código a seguir cria uma operação de espiada assíncrona. O exemplo de código envia uma mensagem para uma fila de mensagens local e, em seguida, chama BeginPeek(TimeSpan, Object, AsyncCallback), passando: um valor de tempo limite de dez segundos; um inteiro exclusivo que identifica essa mensagem específica; e uma nova instância de que identifica o manipulador de AsyncCallback eventos, MyPeekCompleted. Quando um PeekCompleted evento é gerado, o manipulador de eventos espia a mensagem e grava o corpo da mensagem e o identificador de mensagem inteiro na tela.

#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));
    }
}

Comentários

Quando você usa essa sobrecarga, o retorno de chamada especificado no parâmetro de retorno de chamada é invocado diretamente quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira; o PeekCompleted evento não é gerado. As outras sobrecargas de BeginPeek dependem desse componente para acionar o PeekCompleted evento.

PeekCompleted também será gerado se já existir uma mensagem na fila.

O BeginPeek método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginPeek é assíncrono, você pode chamá-lo para espiar a fila sem bloquear o thread atual de execução. Para espiar a fila de forma síncrona, use o Peek método .

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

BeginPeek retorna um IAsyncResult que identifica a operação assíncrona que o método iniciou. Você pode usá-lo IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndPeek(IAsyncResult) que seja chamado. No entanto, se você iniciar várias operações assíncronas, poderá colocar seus IAsyncResult valores em uma matriz e especificar se deseja aguardar a conclusão de todas as operações ou de qualquer operação. Nesse caso, você usa a AsyncWaitHandle propriedade do IAsyncResult para identificar a operação concluída.

O objeto de estado associa informações de estado à operação. Por exemplo, se você chamar BeginPeek várias vezes para iniciar várias operações, poderá identificar cada operação por meio de um objeto de estado separado que você definir.

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

BeginPeek(TimeSpan, Object)

Inicia uma operação assíncrona de espiada que tem um tempo limite especificado e um objeto de estado especificado, que fornece informações associadas durante todo o tempo de vida da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.

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

Um TimeSpan que indica o intervalo de tempo para aguardar uma mensagem se tornar disponível.

stateObject: Object

Um objeto de estado, especificado pelo aplicativo, que contém informações associadas à operação assíncrona.

Retornos

IAsyncResult

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Exemplos

O exemplo de código a seguir cria uma operação de espiada assíncrona, usando o caminho da fila ".\myQueue". Ele cria um manipulador de eventos, MyPeekCompletede o anexa ao delegado do PeekCompleted manipulador de eventos. BeginPeek é chamado, com um tempo limite de um minuto. Cada chamada para BeginPeek tem um inteiro associado exclusivo que identifica essa operação específica. Quando um PeekCompleted evento é acionado ou o tempo limite expirado, a mensagem, se houver, é recuperada e seu corpo e o identificador inteiro específico da operação são gravados na tela. Em seguida, BeginPeek é chamado novamente para iniciar uma nova operação de espiada assíncrona com o mesmo tempo limite e o inteiro associado da operação recém-concluída.

#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

Comentários

No processamento assíncrono, você usa BeginPeek para acionar o PeekCompleted evento quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expirou.

PeekCompleted também será gerado se já existir uma mensagem na fila.

Use essa sobrecarga para associar informações à operação que será preservada durante todo o tempo de vida da operação. O manipulador de eventos pode acessar essas informações examinando a AsyncState propriedade do IAsyncResult associado à operação.

Para usar BeginPeek, crie um manipulador de eventos que processe os resultados da operação assíncrona e associe-o ao representante do evento. BeginPeek inicia uma operação de espiada assíncrona; o MessageQueue é notificado, por meio do acionamento do PeekCompleted evento, quando uma mensagem chega na fila. Em MessageQueue seguida, o pode acessar a mensagem chamando EndPeek(IAsyncResult) ou recuperando o resultado usando o PeekCompletedEventArgs.

O BeginPeek método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginPeek é assíncrono, você pode chamá-lo para espiar a fila sem bloquear o thread atual de execução. Para espiar a fila de forma síncrona, use o Peek método .

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

Essa sobrecarga especifica um tempo limite e um objeto de estado. Se o intervalo especificado pelo timeout parâmetro expirar, esse componente acionará o PeekCompleted evento. Como nenhuma mensagem existe, uma chamada subsequente para EndPeek(IAsyncResult) gerará uma exceção.

Você também pode usar o objeto de estado para passar informações entre threads de processo. Se um thread for iniciado, mas o retorno de chamada estiver em um thread diferente em um cenário assíncrono, o objeto de estado será empacotado e passado de volta junto com as informações do evento.

Se CanRead for false, o evento de conclusão será gerado, mas uma exceção será gerada ao chamar EndPeek(IAsyncResult).

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

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

Inicia uma operação de espiada assíncrona que tem um tempo limite especificado e usa um cursor específico, uma ação de espiada especificada e um objeto de estado especificado. O objeto de estado fornece informações associadas em todo o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.

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

Um TimeSpan que indica o intervalo de tempo para aguardar uma mensagem se tornar disponível.

cursor: Cursor

Um Cursor que mantém uma posição específica na fila de mensagens.

action: PeekAction

Um dos valores de PeekAction. Indica se a mensagem atual ou a próxima na fila de mensagens deve ser espiada.

state: Object

Um objeto de estado, especificado pelo aplicativo, que contém informações associadas à operação assíncrona.

callback: AsyncCallback

O AsyncCallback que recebe a notificação de conclusão de operação assíncrona.

Retornos

IAsyncResult

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

ArgumentOutOfRangeException

Um valor diferente de PeekAction.Current ou PeekAction.Next foi especificado para o parâmetro action.

ArgumentNullException

O parâmetro cursor é null.

ArgumentException

O valor especificado para o parâmetro timeout não é válido.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Comentários

Quando você usa essa sobrecarga, o retorno de chamada especificado no parâmetro de retorno de chamada é invocado diretamente quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira. O PeekCompleted evento não é gerado. As outras sobrecargas de BeginPeek dependem desse componente para acionar o PeekCompleted evento.

PeekCompleted também será gerado se já existir uma mensagem na fila.

O BeginPeek método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginPeek é assíncrono, você pode chamá-lo para espiar a fila sem bloquear o thread atual de execução. Para espiar a fila de forma síncrona, use o Peek método .

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

BeginPeek retorna um IAsyncResult que identifica a operação assíncrona iniciada pelo método . Você pode usá-lo IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndPeek(IAsyncResult) que seja chamado. No entanto, se você iniciar várias operações assíncronas, poderá colocar seus IAsyncResult valores em uma matriz e especificar se deseja aguardar a conclusão de todas as operações ou de qualquer operação. Nesse caso, use a AsyncWaitHandle propriedade do IAsyncResult para identificar a operação concluída.

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

BeginPeek()

Inicia uma operação de espiada assíncrona que não tem um tempo limite. A operação não será concluída até que uma mensagem fique disponível na fila.

public:
 IAsyncResult ^ BeginPeek();

public IAsyncResult BeginPeek ();

member this.BeginPeek : unit -> IAsyncResult

Public Function BeginPeek () As IAsyncResult

Retornos

IAsyncResult

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Exemplos

O exemplo de código a seguir cria um manipulador de eventos chamado MyPeekCompleted, anexa-o ao delegado do PeekCompleted manipulador de eventos e chama BeginPeek para iniciar uma operação de espiada assíncrona na fila localizada no caminho ".\myQueue". Quando um PeekCompleted evento é gerado, o exemplo espia a mensagem e grava seu corpo na tela. Em seguida, o exemplo chama BeginPeek novamente para iniciar uma nova operação de espiada assíncrona.

#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

Comentários

No processamento assíncrono, você usa BeginPeek para acionar o PeekCompleted evento quando uma mensagem fica disponível na fila.

PeekCompleted também será gerado se já existir uma mensagem na fila.

O BeginPeek método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginPeek é assíncrono, você pode chamá-lo para espiar a fila sem bloquear o thread atual de execução. Para espiar a fila de forma síncrona, use o Peek método .

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

O IAsyncResult que BeginPeek retorna identifica a operação assíncrona que o método iniciou. Você pode usá-lo IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndPeek(IAsyncResult) que seja chamado. No entanto, se você iniciar várias operações assíncronas, poderá colocar seus IAsyncResult valores em uma matriz e especificar se deseja aguardar a conclusão de todas as operações ou de qualquer operação. Nesse caso, você usa a AsyncWaitHandle propriedade do IAsyncResult para identificar a operação concluída.

Se CanRead for false, o evento de conclusão será gerado, mas uma exceção será gerada ao chamar EndPeek(IAsyncResult).

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

BeginPeek(TimeSpan)

Inicia uma operação de espiada assíncrona que tem um tempo limite especificado. A operação não será concluída até que uma mensagem fique disponível na fila ou que ocorra o tempo limite.

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

Um TimeSpan que indica o intervalo de tempo para aguardar uma mensagem se tornar disponível.

Retornos

IAsyncResult

O IAsyncResult que identifica a solicitação assíncrona postada.

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Exemplos

O exemplo de código a seguir cria uma operação de espiada assíncrona, usando o caminho da fila ".\myQueue". Ele cria um manipulador de eventos, MyPeekCompletede o anexa ao delegado do PeekCompleted manipulador de eventos. BeginPeek é chamado com um tempo limite de um minuto para iniciar a operação de espiada assíncrona. Quando um PeekCompleted evento é acionado ou o tempo limite expira, a mensagem é recuperada se houver um e seu corpo é gravado na tela. Em seguida, BeginPeek é chamado novamente para iniciar uma nova operação de espiada assíncrona com o mesmo tempo limite.

#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

Comentários

No processamento assíncrono, você usa BeginPeek para acionar o PeekCompleted evento quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expirou.

PeekCompleted também será gerado se já existir uma mensagem na fila.

O BeginPeek método retorna imediatamente, mas a operação assíncrona não é concluída até que o manipulador de eventos seja chamado.

Como BeginPeek é assíncrono, você pode chamá-lo para espiar a fila sem bloquear o thread atual de execução. Para espiar a fila de forma síncrona, use o Peek método .

Depois que uma operação assíncrona for concluída, você poderá chamar BeginPeek ou BeginReceive novamente no manipulador de eventos para continuar recebendo notificações.

Essa sobrecarga especifica um tempo limite. Se o intervalo especificado pelo timeout parâmetro expirar, esse componente gerará o PeekCompleted evento. Como nenhuma mensagem existe, uma chamada subsequente para EndPeek(IAsyncResult) gerará uma exceção.

Se CanRead for false, o evento de conclusão será gerado, mas uma exceção será gerada ao chamar EndPeek(IAsyncResult).

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

Acesso thread-safe

O método não é thread-safe.

MessageQueue.BeginPeek Método

Definição

Sobrecargas

BeginPeek(TimeSpan, Object, AsyncCallback)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

BeginPeek(TimeSpan, Object)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

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

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

BeginPeek()

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

BeginPeek(TimeSpan)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Acesso thread-safe

Comentários

Recursos adicionais