MessageQueue.EndPeek(IAsyncResult) Méthode

Référence

Définition

Espace de noms:: System.Messaging

Assembly:: System.Messaging.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Termine l'opération de lecture asynchrone spécifiée.

public:
 System::Messaging::Message ^ EndPeek(IAsyncResult ^ asyncResult);

public System.Messaging.Message EndPeek (IAsyncResult asyncResult);

member this.EndPeek : IAsyncResult -> System.Messaging.Message

Public Function EndPeek (asyncResult As IAsyncResult) As Message

Paramètres

asyncResult: IAsyncResult

IAsyncResult qui identifie l'opération de lecture asynchrone à terminer, et à partir de laquelle un résultat final doit être récupéré.

Retours

Message

Message associé à l'opération asynchrone terminée.

Exceptions

ArgumentNullException

Le paramètre asyncResult a la valeur null.

ArgumentException

La syntaxe du paramètre asyncResult 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 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

Lorsque l’événement PeekCompleted est déclenché, EndPeek(IAsyncResult) termine l’opération qui a été lancée par l’appel BeginPeek . Pour ce faire, EndPeek(IAsyncResult) consultez le message.

BeginPeek peut spécifier un délai d’attente, ce qui entraîne la levée de l’événement PeekCompleted si le délai d’attente se produit avant qu’un message n’apparaisse dans la file d’attente. Lorsqu’un délai d’attente se produit sans qu’un message arrive dans la file d’attente, un appel suivant à EndPeek(IAsyncResult) lève une exception.

EndPeek(IAsyncResult) est utilisé pour lire le message qui a provoqué la levée de l’événement PeekCompleted .

Si vous souhaitez continuer à consulter les messages de manière asynchrone, vous pouvez à nouveau appeler BeginPeek après avoir appelé EndPeek(IAsyncResult).

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

S’applique à

Partager via