MessageQueue.BeginPeek Méthode

  • Référence

Définition

Espace de noms:
System.Messaging
Assembly:
System.Messaging.dll

Lance une opération de lecture asynchrone en demandant à Message Queuing de commencer la lecture d'un message et d'avertir le gestionnaire d'événements lorsqu'elle aura terminé.

Surcharges

BeginPeek(TimeSpan, Object, AsyncCallback)

Lance une opération de lecture asynchrone avec un délai et un objet d'état spécifiés, permettant ainsi de disposer de données associées pendant toute la durée de vie de l'opération. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.
BeginPeek(TimeSpan, Object)

Lance une opération de lecture asynchrone avec un délai et un objet d'état spécifiés, permettant ainsi de disposer de données associées pendant toute la durée de vie de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Initialise une opération de lecture asynchrone qui a un délai d'expiration spécifié et utilise un curseur spécifié, une action de lecture spécifiée et un objet d'état spécifié. L'objet d'état fournit des informations associées pendant la durée de vie de l'opération. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.
BeginPeek()

Lance une opération de lecture asynchrone sans délai d’expiration. L’opération n’est pas terminée tant qu’un message ne s’affiche pas dans la file d’attente.
BeginPeek(TimeSpan)

Lance une opération de peek asynchrone avec un délai d’expiration spécifié. L’opération n’est pas terminée tant qu’un message ne s’affiche pas dans la file d’attente ou que l’opération n’a pas expiré.

BeginPeek(TimeSpan, Object, AsyncCallback)

Lance une opération de lecture asynchrone avec un délai et un objet d'état spécifiés, permettant ainsi de disposer de données associées pendant toute la durée de vie de l'opération. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.

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

Paramètres

timeout
TimeSpan

TimeSpan qui indique la durée d'attente pour qu'un message soit disponible.

stateObject
Object

Objet d'état, spécifié par l'application, qui comporte les données associées à l'opération asynchrone.

callback
AsyncCallback

AsyncCallback qui recevra la notification de la fin de l'opération asynchrone.

Retours

IAsyncResult

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide.

MessageQueueException

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant crée une opération d’aperçu asynchrone. L’exemple de code envoie un message à une file d’attente de messages locale, puis appelle BeginPeek(TimeSpan, Object, AsyncCallback), en passant : une valeur de délai d’attente de dix secondes ; un entier unique qui identifie ce message particulier ; et une nouvelle instance de qui identifie le gestionnaire d’événementsAsyncCallback, MyPeekCompleted. Lorsqu’un PeekCompleted événement est déclenché, le gestionnaire d’événements examine le message et écrit le corps du message et l’identificateur de message entier dans l’écran.

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

Remarques

Lorsque vous utilisez cette surcharge, le rappel spécifié dans le paramètre de rappel est appelé directement lorsqu’un message devient disponible dans la file d’attente ou lorsque l’intervalle de temps spécifié a expiré ; l’événement PeekCompleted n’est pas déclenché. Les autres surcharges de s’appuient BeginPeek sur ce composant pour déclencher l’événement PeekCompleted .

PeekCompleted est également déclenché si un message existe déjà dans la file d’attente.

La BeginPeek méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant BeginPeek asynchrone, vous pouvez l’appeler pour consulter la file d’attente sans bloquer le thread d’exécution actuel. Pour effectuer un aperçu synchrone de la file d’attente, utilisez la Peek méthode .

Une fois l’opération asynchrone terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

BeginPeek retourne un IAsyncResult qui identifie l’opération asynchrone que la méthode a démarrée. Vous pouvez l’utiliser IAsyncResult pendant toute la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle n’est EndPeek(IAsyncResult) pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de IAsyncResult pour identifier l’opération terminée.

L’objet state associe des informations d’état à l’opération. Par exemple, si vous appelez BeginPeek plusieurs fois pour lancer plusieurs opérations, vous pouvez identifier chaque opération à l’aide d’un objet d’état distinct que vous définissez.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail Disponible
Ordinateur local Oui
Ordinateur local et nom de format direct Oui
Ordinateur distant Non
Ordinateur distant et nom de format direct Oui

Voir aussi

S’applique à

BeginPeek(TimeSpan, Object)

Lance une opération de lecture asynchrone avec un délai et un objet d'état spécifiés, permettant ainsi de disposer de données associées pendant toute la durée de vie de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.

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

Paramètres

timeout
TimeSpan

TimeSpan qui indique la durée d'attente pour qu'un message soit disponible.

stateObject
Object

Objet d'état, spécifié par l'application, qui comporte les données associées à l'opération asynchrone.

Retours

IAsyncResult

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide.

MessageQueueException

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant crée une opération d’aperçu asynchrone, à l’aide du chemin de file d’attente . \myQueue ». Il crée un gestionnaire d’événements, MyPeekCompletedet l’attache au délégué du PeekCompleted gestionnaire d’événements. BeginPeek est appelé, avec un délai d’attente d’une minute. Chaque appel à BeginPeek a un entier associé unique qui identifie cette opération particulière. Lorsqu’un PeekCompleted événement est déclenché ou que le délai d’expiration a expiré, le message, le cas échéant, est récupéré et son corps et l’identificateur entier spécifique à l’opération sont écrits à l’écran. Ensuite, BeginPeek est appelé à nouveau pour lancer une nouvelle opération d’aperçu asynchrone avec le même délai d’attente et l’entier associé de l’opération qui vient d’être terminée.

#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

Remarques

Dans le traitement asynchrone, vous utilisez BeginPeek pour déclencher l’événement PeekCompleted lorsqu’un message devient disponible dans la file d’attente ou lorsque l’intervalle de temps spécifié a expiré.

PeekCompleted est également déclenché si un message existe déjà dans la file d’attente.

Utilisez cette surcharge pour associer des informations à l’opération qui seront conservées pendant toute la durée de vie de l’opération. Le gestionnaire d’événements peut accéder à ces informations en examinant la AsyncState propriété de qui IAsyncResult est associée à l’opération.

Pour utiliser BeginPeek, créez un gestionnaire d’événements qui traite les résultats de l’opération asynchrone et associez-le à votre délégué d’événement. BeginPeek lance une opération d’aperçu asynchrone ; le MessageQueue est averti, par le biais de la déclenchement de l’événement PeekCompleted , lorsqu’un message arrive dans la file d’attente. Le MessageQueue peut ensuite accéder au message en appelant EndPeek(IAsyncResult) ou en récupérant le résultat à l’aide de PeekCompletedEventArgs.

La BeginPeek méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant BeginPeek asynchrone, vous pouvez l’appeler pour consulter la file d’attente sans bloquer le thread d’exécution actuel. Pour effectuer un aperçu synchrone de la file d’attente, utilisez la Peek méthode .

Une fois l’opération asynchrone terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

BeginPeek retourne un IAsyncResult qui identifie l’opération asynchrone que la méthode a démarrée. Vous pouvez l’utiliser IAsyncResult pendant toute la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle n’est EndPeek(IAsyncResult) pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de IAsyncResult pour identifier l’opération terminée.

Cette surcharge spécifie un délai d’attente et un objet d’état. Si l’intervalle spécifié par le timeout paramètre expire, ce composant déclenche l’événement PeekCompleted . Étant donné qu’aucun message n’existe, un appel suivant à EndPeek(IAsyncResult) lève une exception.

L’objet state associe des informations d’état à l’opération. Par exemple, si vous appelez BeginPeek plusieurs fois pour lancer plusieurs opérations, vous pouvez identifier chaque opération à l’aide d’un objet d’état distinct que vous définissez. Pour obtenir une illustration de ce scénario, consultez la section Exemple.

Vous pouvez également utiliser l’objet state pour transmettre des informations entre des threads de processus. Si un thread est démarré mais que le rappel se trouve sur un autre thread dans un scénario asynchrone, l’objet d’état est marshalé et renvoyé avec les informations de l’événement.

Si CanRead a la valeur false, l’événement d’achèvement est déclenché, mais une exception est levée lors de l’appel EndPeek(IAsyncResult)de .

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail Disponible
Ordinateur local Oui
Ordinateur local et nom de format direct Oui
Ordinateur distant Non
Ordinateur distant et nom de format direct Oui

Voir aussi

S’applique à

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

Initialise une opération de lecture asynchrone qui a un délai d'expiration spécifié et utilise un curseur spécifié, une action de lecture spécifiée et un objet d'état spécifié. L'objet d'état fournit des informations associées pendant la durée de vie de l'opération. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.

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

Paramètres

timeout
TimeSpan

TimeSpan qui indique la durée d'attente pour qu'un message soit disponible.

cursor
Cursor

Cursor qui conserve une position spécifique dans la file d'attente de messages.

action
PeekAction

Une des valeurs de l'objet PeekAction. Indique s'il faut lire le message en cours dans la file d'attente ou le message suivant.

state
Object

Objet d'état, spécifié par l'application, qui comporte les données associées à l'opération asynchrone.

callback
AsyncCallback

AsyncCallback qui reçoit la notification de la fin de l'opération asynchrone.

Retours

IAsyncResult

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

ArgumentOutOfRangeException

Une valeur autre que PeekAction.Current ou PeekAction.Next a été spécifiée pour le paramètre action.

ArgumentNullException

Le paramètre cursor a la valeur null.

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide.

MessageQueueException

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Remarques

Lorsque vous utilisez cette surcharge, le rappel spécifié dans le paramètre de rappel est appelé directement lorsqu’un message devient disponible dans la file d’attente ou lorsque l’intervalle de temps spécifié a expiré. L’événement PeekCompleted n’est pas déclenché. Les autres surcharges de s’appuient BeginPeek sur ce composant pour déclencher l’événement PeekCompleted .

PeekCompleted est également déclenché si un message existe déjà dans la file d’attente.

La BeginPeek méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant BeginPeek asynchrone, vous pouvez l’appeler pour consulter la file d’attente sans bloquer le thread d’exécution actuel. Pour effectuer un aperçu synchrone de la file d’attente, utilisez la Peek méthode .

Une fois l’opération asynchrone terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

BeginPeek retourne un IAsyncResult qui identifie l’opération asynchrone démarrée par la méthode . Vous pouvez l’utiliser IAsyncResult pendant toute la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle n’est EndPeek(IAsyncResult) pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, utilisez la AsyncWaitHandle propriété de IAsyncResult pour identifier l’opération terminée.

L’objet state associe des informations d’état à l’opération. Par exemple, si vous appelez BeginPeek plusieurs fois pour lancer plusieurs opérations, vous pouvez identifier chaque opération à l’aide d’un objet d’état distinct que vous définissez.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail Disponible
Ordinateur local Oui
Ordinateur local et nom de format direct Oui
Ordinateur distant Non
Ordinateur distant et nom de format direct Oui

Voir aussi

S’applique à

BeginPeek()

Lance une opération de lecture asynchrone sans délai d’expiration. L’opération n’est pas terminée tant qu’un message ne s’affiche pas dans la file d’attente.

public:
 IAsyncResult ^ BeginPeek();
public IAsyncResult BeginPeek ();
member this.BeginPeek : unit -> IAsyncResult
Public Function BeginPeek () As IAsyncResult

Retours

IAsyncResult

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

MessageQueueException

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant crée un gestionnaire d’événements nommé MyPeekCompleted, l’attache au délégué du PeekCompleted gestionnaire d’événements et appelle BeginPeek pour lancer une opération d’aperçu asynchrone sur la file d’attente qui se trouve au niveau du chemin d’accès « \myQueue ». Lorsqu’un PeekCompleted événement est déclenché, l’exemple montre comment afficher le message et écrire son corps à l’écran. L’exemple appelle BeginPeek ensuite à nouveau pour lancer une nouvelle opération d’aperçu asynchrone.

#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

Remarques

Dans le traitement asynchrone, vous utilisez BeginPeek pour déclencher l’événement PeekCompleted lorsqu’un message devient disponible dans la file d’attente.

PeekCompleted est également déclenché si un message existe déjà dans la file d’attente.

Pour utiliser BeginPeek, créez un gestionnaire d’événements qui traite les résultats de l’opération asynchrone et associez-le à votre délégué d’événement. BeginPeek lance une opération d’aperçu asynchrone ; le MessageQueue est averti, par le biais de la déclenchement de l’événement PeekCompleted , lorsqu’un message arrive dans la file d’attente. Le MessageQueue peut ensuite accéder au message en appelant EndPeek(IAsyncResult) ou en récupérant le résultat à l’aide de PeekCompletedEventArgs.

La BeginPeek méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant BeginPeek asynchrone, vous pouvez l’appeler pour consulter la file d’attente sans bloquer le thread d’exécution actuel. Pour effectuer un aperçu synchrone de la file d’attente, utilisez la Peek méthode .

Une fois l’opération asynchrone terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

BeginPeek Qui IAsyncResult retourne identifie l’opération asynchrone que la méthode a démarrée. Vous pouvez l’utiliser IAsyncResult pendant toute la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle n’est EndPeek(IAsyncResult) pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de IAsyncResult pour identifier l’opération terminée.

Si CanRead a la valeur false, l’événement d’achèvement est déclenché, mais une exception est levée lors de l’appel EndPeek(IAsyncResult)de .

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail Disponible
Ordinateur local Oui
Ordinateur local et nom de format direct Oui
Ordinateur distant Non
Ordinateur distant et nom de format direct Oui

Voir aussi

S’applique à

BeginPeek(TimeSpan)

Lance une opération de peek asynchrone avec un délai d’expiration spécifié. L’opération n’est pas terminée tant qu’un message ne s’affiche pas dans la file d’attente ou que l’opération n’a pas expiré.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout);
public IAsyncResult BeginPeek (TimeSpan timeout);
member this.BeginPeek : TimeSpan -> IAsyncResult
Public Function BeginPeek (timeout As TimeSpan) As IAsyncResult

Paramètres

timeout
TimeSpan

TimeSpan qui indique la durée d'attente pour qu'un message soit disponible.

Retours

IAsyncResult

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide.

MessageQueueException

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant crée une opération d’aperçu asynchrone, à l’aide du chemin de file d’attente . \myQueue ». Il crée un gestionnaire d’événements, MyPeekCompletedet l’attache au délégué du PeekCompleted gestionnaire d’événements. BeginPeek est appelé avec un délai d’expiration d’une minute, pour lancer l’opération d’aperçu asynchrone. Lorsqu’un PeekCompleted événement est déclenché ou que le délai d’expiration expire, le message est récupéré s’il en existe un et son corps est écrit à l’écran. Est ensuite BeginPeek appelé à nouveau pour lancer une nouvelle opération d’aperçu asynchrone avec le même délai d’expiration.

#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

Remarques

Dans le traitement asynchrone, vous utilisez BeginPeek pour déclencher l’événement PeekCompleted lorsqu’un message devient disponible dans la file d’attente ou lorsque l’intervalle de temps spécifié a expiré.

PeekCompleted est également déclenché si un message existe déjà dans la file d’attente.

Pour utiliser BeginPeek, créez un gestionnaire d’événements qui traite les résultats de l’opération asynchrone et associez-le à votre délégué d’événement. BeginPeek lance une opération d’aperçu asynchrone ; le MessageQueue est averti, par le biais de la déclenchement de l’événement PeekCompleted , lorsqu’un message arrive dans la file d’attente. Le MessageQueue peut ensuite accéder au message en appelant EndPeek(IAsyncResult) ou en récupérant le résultat à l’aide de PeekCompletedEventArgs.

La BeginPeek méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant BeginPeek asynchrone, vous pouvez l’appeler pour consulter la file d’attente sans bloquer le thread d’exécution actuel. Pour effectuer un aperçu synchrone de la file d’attente, utilisez la Peek méthode .

Une fois l’opération asynchrone terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

BeginPeek Qui IAsyncResult retourne identifie l’opération asynchrone que la méthode a démarrée. Vous pouvez l’utiliser IAsyncResult pendant toute la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle n’est EndPeek(IAsyncResult) pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de pour IAsyncResult identifier l’opération terminée.

Cette surcharge spécifie un délai d’attente. Si l’intervalle spécifié par le timeout paramètre expire, ce composant déclenche l’événement PeekCompleted . Étant donné qu’aucun message n’existe, un appel suivant à EndPeek(IAsyncResult) lève une exception.

Si CanRead a la valeur false, l’événement d’achèvement est déclenché, mais une exception est levée lors de l’appel EndPeek(IAsyncResult)de .

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail Disponible
Ordinateur local Oui
Ordinateur local et nom de format direct Oui
Ordinateur distant Non
Ordinateur distant et nom de format direct Oui

Voir aussi

S’applique à

Cohérence de thread

La méthode n’est pas thread-safe.