MessageQueue.BeginPeek Método

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

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Exemplos

O exemplo de código seguinte cria uma operação peek assíncrona. O exemplo de código envia uma mensagem para uma fila de mensagens local, depois chama BeginPeek(TimeSpan, Object, AsyncCallback), passando em: um valor de time-out de dez segundos; um inteiro único que identifica essa mensagem em particular; e uma nova instância disso AsyncCallback que identifica o gestor de eventos, MyPeekCompleted. Quando um PeekCompleted evento é gerado, o gestor de eventos espreita a mensagem e escreve o corpo da mensagem e o identificador inteiro da mensagem no ecrã.

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

Observações

Quando se utiliza esta sobrecarga, o callback especificado no parâmetro de callback é invocado diretamente quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira; o PeekCompleted evento não é levantado. As outras sobrecargas dependem BeginPeek deste componente para elevar o PeekCompleted evento.

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

O BeginPeek método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

BeginPeek devolve a IAsyncResult que identifica a operação assíncrona que o método iniciou. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndPeek(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, usa a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

O objeto de estado associa a informação de estado à operação. Por exemplo, se chamar BeginPeek várias vezes para iniciar várias operações, pode identificar cada operação através de um objeto de estado separado que define.

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver também

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()
• AsyncCallback
• TimeSpan

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

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Exemplos

O seguinte exemplo de código cria uma operação peek assíncrona, usando o caminho da fila ".\myQueue". Cria um gestor de eventos, MyPeekCompleted, e anexa-o ao PeekCompleted delegado do gestor de eventos. BeginPeek é chamado, com um tempo de um minuto. Cada chamada a BeginPeek tem um inteiro único associado que identifica essa operação em particular. Quando um PeekCompleted evento é levantado ou o time-out expira, a mensagem, caso exista, é recuperada e o seu corpo e o identificador inteiro específico da operação são gravados no ecrã. Depois BeginPeek é chamado novamente para iniciar uma nova operação assíncrona de peek com o mesmo time-out e o inteiro associado da operação acabada de concluir.

#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

Observações

No processamento assíncrono, é usado BeginPeek para levantar o PeekCompleted evento quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira.

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

Utilize esta sobrecarga para associar informações à operação que serão preservadas ao longo de toda a vida útil da operação. O gestor de eventos pode aceder a esta informação observando a AsyncState propriedade de o IAsyncResult que está associada à operação.

Para usar BeginPeek, crie um gestor de eventos que processe os resultados da operação assíncrona e associe-o ao seu delegado de eventos. BeginPeek inicia uma operação de peek assíncrona; é MessageQueue notificado, através do levantamento do PeekCompleted evento, quando uma mensagem chega à fila. Podem MessageQueue então aceder à mensagem chamando EndPeek(IAsyncResult) ou recuperando o resultado usando o PeekCompletedEventArgs.

O BeginPeek método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

BeginPeek devolve a IAsyncResult que identifica a operação assíncrona que o método iniciou. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndPeek(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, usa a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

Esta sobrecarga especifica um time-out e um objeto de estado. Se o intervalo especificado pelo timeout parâmetro expirar, este componente eleva o PeekCompleted evento. Como não existe mensagem, uma chamada subsequente para EndPeek(IAsyncResult) lançará uma exceção.

O objeto de estado associa a informação de estado à operação. Por exemplo, se chamar BeginPeek várias vezes para iniciar várias operações, pode identificar cada operação através de um objeto de estado separado que define. Para uma ilustração deste cenário, veja a secção Exemplo.

Também podes usar o objeto estado para passar informação entre threads de processo. Se um thread for iniciado mas o callback estiver num thread diferente num cenário assíncrono, o objeto de estado é marshalizado e repassado juntamente com a informação do evento.

Se CanRead for false, o evento de conclusão é levantado, mas será lançada uma exceção ao chamar EndPeek(IAsyncResult).

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver também

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()
• TimeSpan

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

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Observações

Quando se utiliza esta sobrecarga, o callback especificado no parâmetro de callback é invocado diretamente quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira. O PeekCompleted evento não é levantado. As outras sobrecargas dependem BeginPeek deste componente para elevar o PeekCompleted evento.

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

O BeginPeek método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

BeginPeek devolve a IAsyncResult que identifica a operação assíncrona iniciada pelo método. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndPeek(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, use a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

O objeto de estado associa a informação de estado à operação. Por exemplo, se chamar BeginPeek várias vezes para iniciar várias operações, pode identificar cada operação através de um objeto de estado separado que define.

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver também

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()
• AsyncCallback
• TimeSpan

public:
 IAsyncResult ^ BeginPeek();

public IAsyncResult BeginPeek();

member this.BeginPeek : unit -> IAsyncResult

Public Function BeginPeek () As IAsyncResult

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Exemplos

O exemplo de código seguinte cria um gestor de eventos chamado MyPeekCompleted, anexa-o ao PeekCompleted delegado do gestor de eventos, e chama BeginPeek para iniciar uma operação de peek assíncrona na fila localizada no caminho ".\myQueue". Quando um PeekCompleted evento é levantado, o exemplo espreita a mensagem e escreve o seu corpo no ecrã. O exemplo chama BeginPeek então novamente para iniciar uma nova operação assíncrona de peek.

#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

Observações

No processamento assíncrono, usa-se BeginPeek para gerar o PeekCompleted evento quando uma mensagem fica disponível na fila.

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

Para usar BeginPeek, crie um gestor de eventos que processe os resultados da operação assíncrona e associe-o ao seu delegado de eventos. BeginPeek inicia uma operação de peek assíncrona; é MessageQueue notificado, através do levantamento do PeekCompleted evento, quando uma mensagem chega à fila. Podem MessageQueue então aceder à mensagem chamando EndPeek(IAsyncResult) ou recuperando o resultado usando o PeekCompletedEventArgs.

O BeginPeek método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

O IAsyncResult que BeginPeek retorna identifica a operação assíncrona que o método iniciou. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndPeek(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, usa a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

Se CanRead for false, o evento de conclusão é levantado, mas será lançada uma exceção ao chamar EndPeek(IAsyncResult).

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver também

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()

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

Devoluções

O IAsyncResult que identifica o pedido assíncrono publicado.

Exceções

Exemplos

O seguinte exemplo de código cria uma operação peek assíncrona, usando o caminho da fila ".\myQueue". Cria um gestor de eventos, MyPeekCompleted, e anexa-o ao PeekCompleted delegado do gestor de eventos. BeginPeek é chamada com um time-out de um minuto, para iniciar a operação de peek assíncrona. Quando um PeekCompleted evento é levantado ou o time-out expira, a mensagem é recuperada, caso exista, e o seu corpo é escrito no ecrã. Depois BeginPeek é chamado novamente para iniciar uma nova operação assíncrona de peek com o mesmo time-out.

#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

Observações

No processamento assíncrono, é usado BeginPeek para levantar o PeekCompleted evento quando uma mensagem fica disponível na fila ou quando o intervalo de tempo especificado expira.

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

Para usar BeginPeek, crie um gestor de eventos que processe os resultados da operação assíncrona e associe-o ao seu delegado de eventos. BeginPeek inicia uma operação de peek assíncrona; é MessageQueue notificado, através do levantamento do PeekCompleted evento, quando uma mensagem chega à fila. Podem MessageQueue então aceder à mensagem chamando EndPeek(IAsyncResult) ou recuperando o resultado usando o PeekCompletedEventArgs.

O BeginPeek método retorna imediatamente, mas a operação assíncrona só é concluída quando o handler de eventos é chamado.

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

Assim que uma operação assíncrona termina, pode ligar BeginPeek ou BeginReceive voltar ao handler de eventos para continuar a receber notificações.

O IAsyncResult que BeginPeek retorna identifica a operação assíncrona que o método iniciou. Pode usar isto IAsyncResult ao longo da vida útil da operação, embora geralmente não o use até EndPeek(IAsyncResult) ser chamado. No entanto, se iniciar várias operações assíncronas, pode colocar os seus IAsyncResult valores num array e especificar se deve esperar que todas as operações ou qualquer operação seja concluída. Neste caso, usa a AsyncWaitHandle propriedade de para IAsyncResult identificar a operação concluída.

Esta sobrecarga especifica um time-out. Se o intervalo especificado pelo timeout parâmetro expirar, este componente eleva o PeekCompleted evento. Como não existe mensagem, uma chamada subsequente para EndPeek(IAsyncResult) lançará uma exceção.

Se CanRead for false, o evento de conclusão é levantado, mas será lançada uma exceção ao chamar EndPeek(IAsyncResult).

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

Modo de grupo de trabalho	Available
Computador local	Yes
Computador local e nome do formato direto	Yes
Computador remoto	No
Computador remoto e nome do formato direto	Yes

Ver também

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()
• TimeSpan