Freigeben über


MessageQueue.EndPeek(IAsyncResult) Methode

Definition

Schließt den angegebenen asynchronen Lesevorgang ab.

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

Parameter

asyncResult
IAsyncResult

Ein IAsyncResult, das den abzuschließenden asynchronen Lesevorgang bestimmt und über das das Endergebnis abgerufen werden kann.

Gibt zurück

Die dem abgeschlossenen asynchronen Vorgang zugeordnete Message.

Ausnahmen

Der asyncResult-Parameter ist null.

Die Syntax des asyncResult-Parameters ist ungültig.

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird ein Ereignishandler namens MyPeekCompletederstellt, an den PeekCompleted Ereignishandlerdelegaten angefügt und aufgerufen BeginPeek , um einen asynchronen Einsehenvorgang für die Warteschlange zu initiieren, die sich unter dem Pfad ".\myQueue" befindet. Wenn ein PeekCompleted Ereignis ausgelöst wird, zeigt das Beispiel die Nachricht an und schreibt ihren Text auf den Bildschirm. Im Beispiel wird dann erneut aufgerufen BeginPeek , um einen neuen asynchronen Einsehenvorgang zu initiieren.

#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

Hinweise

Wenn das PeekCompleted Ereignis ausgelöst wird, schließt den Vorgang ab, EndPeek(IAsyncResult) der durch den BeginPeek Aufruf initiiert wurde. EndPeek(IAsyncResult) Dazu wird die Nachricht eingesehen.

BeginPeek kann ein Timeout angeben, das dazu führt, dass das PeekCompleted Ereignis ausgelöst wird, wenn das Timeout auftritt, bevor eine Nachricht in der Warteschlange angezeigt wird. Wenn ein Timeout auftritt, ohne dass eine Nachricht in der Warteschlange eingeht, löst ein nachfolgender Aufruf von EndPeek(IAsyncResult) eine Ausnahme aus.

EndPeek(IAsyncResult) wird verwendet, um die Nachricht zu lesen, die das PeekCompleted Ereignis ausgelöst hat.

Wenn Sie weiterhin Nachrichten asynchron einsehen möchten, können Sie nach dem Aufrufen EndPeek(IAsyncResult)von erneut aufrufenBeginPeek.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Gilt für:

Weitere Informationen