MessageQueue.BeginPeek Metodo

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

Parametri

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.

Eccezioni

Esempio

Nell'esempio di codice seguente viene creata un'operazione di anteprima asincrona. Nell'esempio di codice viene inviato un messaggio a una coda di messaggi locale BeginPeek(TimeSpan, Object, AsyncCallback), quindi viene chiamato il passaggio: un valore di timeout di dieci secondi, un numero intero univoco che identifica il messaggio specifico e una nuova AsyncCallback istanza di che identifica il gestore eventiMyPeekCompleted. Quando viene generato un PeekCompleted evento, il gestore eventi visualizza il messaggio e scrive il corpo del messaggio e l'identificatore di messaggio intero nella schermata.

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

Commenti

Quando si usa questo overload, il callback specificato nel parametro callback viene richiamato direttamente quando un messaggio diventa disponibile nella coda o quando è scaduto l'intervallo di tempo specificato; l'evento PeekCompleted non viene generato. Gli altri overload di BeginPeek si basano su questo componente per generare l'evento PeekCompleted .

PeekCompleted viene generato anche se esiste già un messaggio nella coda.

Il BeginPeek metodo restituisce immediatamente, ma l'operazione asincrona non viene completata finché non viene chiamato il gestore eventi.

Poiché BeginPeek è asincrono, è possibile chiamarlo per visualizzare la coda senza bloccare il thread corrente di esecuzione. Per visualizzare in modo sincrono la coda, usare il Peek metodo .

Una volta completata un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive nuovamente nel gestore eventi per mantenere la ricezione delle notifiche.

BeginPeek restituisce un oggetto IAsyncResult che identifica l'operazione asincrona avviata dal metodo. È possibile usare questa operazione IAsyncResult durante tutta la durata dell'operazione, anche se in genere non viene chiamato fino a quando EndPeek(IAsyncResult) non viene chiamato. Tuttavia, se si avviano diverse operazioni asincrone, è possibile inserire i relativi IAsyncResult valori in una matrice e specificare se attendere il completamento di tutte le operazioni o qualsiasi operazione. In questo caso si usa la AsyncWaitHandle proprietà dell'oggetto IAsyncResult per identificare l'operazione completata.

L'oggetto state associa le informazioni sullo stato all'operazione. Ad esempio, se si chiama BeginPeek più volte per avviare più operazioni, è possibile identificare ogni operazione tramite un oggetto di stato separato definito.

La tabella seguente mostra se questo metodo è disponibile in varie modalità gruppo di lavoro.

Vedi anche

• 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

Parametri

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.

Eccezioni

Esempio

Nell'esempio di codice seguente viene creata un'operazione di anteprima asincrona usando il percorso della coda ".\myQueue". Crea un gestore eventi, MyPeekCompletede lo collega al delegato del PeekCompleted gestore eventi. BeginPeek viene chiamato, con timeout di un minuto. Ogni chiamata a BeginPeek ha un intero associato univoco che identifica tale operazione specifica. Quando un PeekCompleted evento viene generato o il timeout scaduto, il messaggio, se presente, viene recuperato e il relativo corpo e l'identificatore intero specifico dell'operazione vengono scritti nella schermata. Viene BeginPeek quindi chiamato di nuovo per avviare una nuova operazione asincrona con lo stesso timeout e l'intero associato dell'operazione appena completata.

#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

Commenti

Nell'elaborazione asincrona si usa BeginPeek per generare l'evento quando un messaggio diventa disponibile nella coda o quando è scaduto l'intervallo PeekCompleted di tempo specificato.

PeekCompleted viene generato anche se esiste già un messaggio nella coda.

Usare questo overload per associare le informazioni all'operazione che verrà mantenuta durante la durata dell'operazione. Il gestore eventi può accedere a queste informazioni esaminando la AsyncState proprietà dell'oggetto IAsyncResult associato all'operazione.

Per usare BeginPeek, creare un gestore eventi che elabora i risultati dell'operazione asincrona e associarlo al delegato dell'evento. BeginPeek avvia un'operazione asincrona; viene MessageQueue notificata, tramite la generazione dell'evento PeekCompleted , quando un messaggio arriva nella coda. L'oggetto MessageQueue può quindi accedere al messaggio chiamando EndPeek(IAsyncResult) o recuperando il risultato usando .PeekCompletedEventArgs

Il BeginPeek metodo restituisce immediatamente, ma l'operazione asincrona non viene completata finché non viene chiamato il gestore eventi.

Poiché BeginPeek è asincrono, è possibile chiamarlo per visualizzare la coda senza bloccare il thread corrente di esecuzione. Per visualizzare in modo sincrono la coda, usare il Peek metodo .

Una volta completata un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive nuovamente nel gestore eventi per mantenere la ricezione delle notifiche.

BeginPeek restituisce un oggetto IAsyncResult che identifica l'operazione asincrona avviata dal metodo. È possibile usare questa operazione IAsyncResult durante tutta la durata dell'operazione, anche se in genere non viene chiamato fino a quando EndPeek(IAsyncResult) non viene chiamato. Tuttavia, se si avviano diverse operazioni asincrone, è possibile inserire i relativi IAsyncResult valori in una matrice e specificare se attendere il completamento di tutte le operazioni o qualsiasi operazione. In questo caso si usa la AsyncWaitHandle proprietà dell'oggetto IAsyncResult per identificare l'operazione completata.

Questo overload specifica un timeout e un oggetto state. Se l'intervallo specificato dal timeout parametro scade, questo componente genera l'evento PeekCompleted . Poiché non esiste alcun messaggio, una chiamata successiva a EndPeek(IAsyncResult) genererà un'eccezione.

L'oggetto state associa le informazioni sullo stato all'operazione. Ad esempio, se si chiama BeginPeek più volte per avviare più operazioni, è possibile identificare ogni operazione tramite un oggetto di stato separato definito. Per un'illustrazione di questo scenario, vedere la sezione Esempio.

È anche possibile usare l'oggetto state per passare informazioni tra thread di processo. Se viene avviato un thread, ma il callback si trova in un thread diverso in uno scenario asincrono, l'oggetto state viene eseguito il marshalling e passato insieme alle informazioni dell'evento.

Se CanRead è false, viene generato l'evento di completamento, ma viene generata un'eccezione quando si chiama EndPeek(IAsyncResult).

La tabella seguente mostra se questo metodo è disponibile in varie modalità gruppo di lavoro.

Vedi anche

• 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

Parametri

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.

Eccezioni

Commenti

Quando si usa questo overload, il callback specificato nel parametro di callback viene richiamato direttamente quando un messaggio diventa disponibile nella coda o quando l'intervallo di tempo specificato è scaduto. L'evento PeekCompleted non viene generato. Gli altri overload di BeginPeek si basano su questo componente per generare l'evento PeekCompleted .

PeekCompleted viene generato anche se nella coda esiste già un messaggio.

Il BeginPeek metodo restituisce immediatamente, ma l'operazione asincrona non viene completata fino a quando non viene chiamato il gestore eventi.

Poiché BeginPeek è asincrono, è possibile chiamarlo per visualizzare la coda senza bloccare il thread corrente di esecuzione. Per visualizzare in modo sincrono la coda, usare il Peek metodo .

Al termine di un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive di nuovo nel gestore eventi per mantenere la ricezione delle notifiche.

BeginPeek restituisce un IAsyncResult oggetto che identifica l'operazione asincrona avviata dal metodo . È possibile usarlo IAsyncResult per tutta la durata dell'operazione, anche se in genere non viene usato fino a EndPeek(IAsyncResult) quando non viene chiamato. Tuttavia, se si avviano diverse operazioni asincrone, è possibile posizionarne IAsyncResult i valori in una matrice e specificare se attendere il completamento di tutte le operazioni o qualsiasi operazione. In questo caso, utilizzare la AsyncWaitHandle proprietà di IAsyncResult per identificare l'operazione completata.

L'oggetto stato associa le informazioni sullo stato all'operazione. Ad esempio, se si chiama BeginPeek più volte per avviare più operazioni, è possibile identificare ogni operazione tramite un oggetto di stato separato definito dall'utente.

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Vedi anche

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

public:
 IAsyncResult ^ BeginPeek();

public IAsyncResult BeginPeek ();

member this.BeginPeek : unit -> IAsyncResult

Public Function BeginPeek () As IAsyncResult

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.

Eccezioni

Esempio

L'esempio di codice seguente crea un gestore eventi denominato MyPeekCompleted, lo associa al delegato del PeekCompleted gestore eventi e chiama BeginPeek per avviare un'operazione di visualizzazione asincrona nella coda che si trova nel percorso ".\myQueue". Quando viene generato un PeekCompleted evento, l'esempio visualizza il messaggio e ne scrive il corpo sullo schermo. L'esempio chiama BeginPeek di nuovo per avviare una nuova operazione di visualizzazione asincrona.

#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

Commenti

Nell'elaborazione asincrona si usa BeginPeek per generare l'evento PeekCompleted quando un messaggio diventa disponibile nella coda.

PeekCompleted viene generato anche se nella coda esiste già un messaggio.

Per usare BeginPeek, creare un gestore eventi che elabora i risultati dell'operazione asincrona e associarlo al delegato dell'evento. BeginPeek avvia un'operazione di visualizzazione asincrona; l'oggetto MessageQueue riceve una notifica, tramite la generazione dell'evento PeekCompleted , quando un messaggio arriva nella coda. Può MessageQueue quindi accedere al messaggio chiamando EndPeek(IAsyncResult) o recuperando il risultato usando .PeekCompletedEventArgs

Il BeginPeek metodo restituisce immediatamente, ma l'operazione asincrona non viene completata fino a quando non viene chiamato il gestore eventi.

Poiché BeginPeek è asincrono, è possibile chiamarlo per visualizzare la coda senza bloccare il thread corrente di esecuzione. Per visualizzare in modo sincrono la coda, usare il Peek metodo .

Al termine di un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive di nuovo nel gestore eventi per mantenere la ricezione delle notifiche.

Oggetto IAsyncResult che BeginPeek restituisce identifica l'operazione asincrona avviata dal metodo. È possibile usarlo IAsyncResult per tutta la durata dell'operazione, anche se in genere non viene usato fino a EndPeek(IAsyncResult) quando non viene chiamato. Tuttavia, se si avviano diverse operazioni asincrone, è possibile posizionarne IAsyncResult i valori in una matrice e specificare se attendere il completamento di tutte le operazioni o qualsiasi operazione. In questo caso, si usa la AsyncWaitHandle proprietà di IAsyncResult per identificare l'operazione completata.

Se CanRead è false, viene generato l'evento di completamento, ma viene generata un'eccezione quando si chiama EndPeek(IAsyncResult).

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Vedi anche

• 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

Parametri

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.

Eccezioni

Esempio

L'esempio di codice seguente crea un'operazione di visualizzazione asincrona usando il percorso della coda ".\myQueue". Crea un gestore eventi, MyPeekCompleted, e lo associa al delegato del PeekCompleted gestore eventi. BeginPeek viene chiamato con un timeout di un minuto, per avviare l'operazione di visualizzazione asincrona. Quando viene generato un PeekCompleted evento o il timeout scade, il messaggio viene recuperato se esistente e il relativo corpo viene scritto sullo schermo. Viene quindi BeginPeek chiamato di nuovo per avviare una nuova operazione di visualizzazione asincrona con lo stesso timeout.

#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

Commenti

Nell'elaborazione asincrona si usa BeginPeek per generare l'evento PeekCompleted quando un messaggio diventa disponibile nella coda o quando è scaduto l'intervallo di tempo specificato.

PeekCompleted viene generato anche se nella coda esiste già un messaggio.

Per usare BeginPeek, creare un gestore eventi che elabora i risultati dell'operazione asincrona e associarlo al delegato dell'evento. BeginPeek avvia un'operazione di visualizzazione asincrona; l'oggetto MessageQueue riceve una notifica, tramite la generazione dell'evento PeekCompleted , quando un messaggio arriva nella coda. Può MessageQueue quindi accedere al messaggio chiamando EndPeek(IAsyncResult) o recuperando il risultato usando .PeekCompletedEventArgs

Il BeginPeek metodo restituisce immediatamente, ma l'operazione asincrona non viene completata fino a quando non viene chiamato il gestore eventi.

Poiché BeginPeek è asincrono, è possibile chiamarlo per visualizzare la coda senza bloccare il thread corrente di esecuzione. Per visualizzare in modo sincrono la coda, usare il Peek metodo .

Al termine di un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive di nuovo nel gestore eventi per mantenere la ricezione delle notifiche.

Oggetto IAsyncResult che BeginPeek restituisce identifica l'operazione asincrona avviata dal metodo. È possibile usarlo IAsyncResult per tutta la durata dell'operazione, anche se in genere non viene usato fino a EndPeek(IAsyncResult) quando non viene chiamato. Tuttavia, se si avviano diverse operazioni asincrone, è possibile posizionarne IAsyncResult i valori in una matrice e specificare se attendere il completamento di tutte le operazioni o qualsiasi operazione. In questo caso si usa la AsyncWaitHandle proprietà dell'oggetto IAsyncResult per identificare l'operazione completata.

Questo overload specifica un timeout. Se l'intervallo specificato dal timeout parametro scade, questo componente genera l'evento PeekCompleted . Poiché non esiste alcun messaggio, una chiamata successiva a EndPeek(IAsyncResult) genererà un'eccezione.

Se CanRead è false, viene generato l'evento di completamento, ma viene generata un'eccezione quando si chiama EndPeek(IAsyncResult).

La tabella seguente mostra se questo metodo è disponibile in varie modalità gruppo di lavoro.

Vedi anche

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