Compartilhar via


MessageQueue.BeginPeek Método

Definição

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

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

Exceções

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

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 do que identifica o manipulador de AsyncCallback eventos, MyPeekCompleted. Quando um PeekCompleted evento é acionado, 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 gerar o PeekCompleted evento.

PeekCompleted também será gerado se uma mensagem já existir 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 usar isso IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndPeek(IAsyncResult) ser chamada. 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 state 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 definido.

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

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

Exceções

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

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 é gerado 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 gerar 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 uma mensagem já existir 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 delegado de eventos. 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.

BeginPeek retorna um IAsyncResult que identifica a operação assíncrona iniciada pelo método . Você pode usar isso IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndPeek(IAsyncResult) ser chamada. 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.

Essa sobrecarga especifica um tempo limite e um objeto de estado. 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.

O objeto state 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 definido. Para obter uma ilustração desse cenário, consulte a seção Exemplo.

Você também pode usar o objeto state 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á marshalado e passado novamente 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

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

Exceções

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

O parâmetro cursor é null.

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

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 gerar o PeekCompleted evento.

PeekCompleted também será gerado se uma mensagem já existir 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 usar isso IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndPeek(IAsyncResult) ser chamada. 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.

O objeto state 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 definido.

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

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

Exceções

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, o anexa 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 é acionado, 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 gerar o PeekCompleted evento quando uma mensagem fica disponível na fila.

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

Para usar BeginPeek, crie um manipulador de eventos que processe os resultados da operação assíncrona e associe-o ao delegado de eventos. 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.

O IAsyncResult que BeginPeek retorna identifica a operação assíncrona iniciada pelo método . Você pode usar isso IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndPeek(IAsyncResult) ser chamada. 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

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

Exceções

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

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 gerar 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 uma mensagem já existir na fila.

Para usar BeginPeek, crie um manipulador de eventos que processe os resultados da operação assíncrona e associe-o ao delegado de eventos. 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.

O IAsyncResult que BeginPeek retorna identifica a operação assíncrona iniciada pelo método . Você pode usar isso IAsyncResult durante todo o tempo de vida da operação, embora geralmente não a use até EndPeek(IAsyncResult) ser chamada. 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.

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.