MessageQueue.EndPeek-Methode

Schließt den angegebenen asynchronen Lesevorgang ab.

Namespace: System.Messaging
Assembly: System.Messaging (in system.messaging.dll)

Syntax

'Declaration
Public Function EndPeek ( _
    asyncResult As IAsyncResult _
) As Message
'Usage
Dim instance As MessageQueue
Dim asyncResult As IAsyncResult
Dim returnValue As Message

returnValue = instance.EndPeek(asyncResult)

public Message EndPeek (
    IAsyncResult asyncResult
)

public:
Message^ EndPeek (
    IAsyncResult^ asyncResult
)

public Message EndPeek (
    IAsyncResult asyncResult
)

public function EndPeek (
    asyncResult : IAsyncResult
) : Message

Parameter

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

Rückgabewert

Die dem abgeschlossenen asynchronen Vorgang zugeordnete Message.

Ausnahmen

Ausnahmetyp	Bedingung
ArgumentNullException	Der asyncResult-Parameter ist NULL (Nothing in Visual Basic).
ArgumentException	Die Syntax des asyncResult-Parameters ist ungültig.
MessageQueueException	Fehler beim Zugriff auf eine Message Queuing-Methode.

Hinweise

Wenn das PeekCompleted-Ereignis ausgelöst wird, schließt EndPeek den durch den BeginPeek-Aufruf initiierten Vorgang ab. Hierzu sieht EndPeek die Meldung ein.

Beim Aufruf von BeginPeek kann ein Timeout angegeben werden. In diesem Fall wird das PeekCompleted-Ereignis ausgelöst, wenn der Timeout auftritt, bevor eine Meldung in die Warteschlange eingeht. Die IsCompleted-Eigenschaft des asyncResult-Parameters wird hierbei auf true festgelegt, dem Vorgang ist jedoch keine Meldung zugeordnet. Wenn ein Timeout auftritt, ohne dass eine Meldung in die Warteschlange eingeht, wird bei einem nachfolgenden Aufruf von EndPeek eine Ausnahme ausgelöst.

EndPeek wird zum Lesen der Meldung verwendet, die das PeekCompleted-Ereignis verursacht hat.

Wenn Sie mit dem asynchronen Einsehen von Meldungen fortfahren möchten, können Sie nach dem Aufruf von EndPeek erneut BeginPeek aufrufen.

Der folgenden Tabelle können Sie entnehmen, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokaler Computer	Ja
Lokaler Computer + direkter Formatname	Ja
Remotecomputer	Nein
Lokaler Computer + direkter Formatname	Ja

Beispiel

Im folgenden Codebeispiel wird ein Ereignishandler mit der Bezeichnung MyPeekCompleted erstellt und mit dem PeekCompleted-Ereignishandlerdelegaten verbunden, und es wird BeginPeek aufgerufen, um einen asynchronen Lesevorgang aus der Warteschlange unter dem Pfad ".\myQueue" zu initiieren. Beim Auslösen eines PeekCompleted-Ereignisses wird in diesem Beispiel die Meldung eingesehen und der Meldungstext auf dem Bildschirm ausgegeben. Daraufhin wird erneut BeginPeek aufgerufen, um einen weiteren asynchronen Lesevorgang zu initiieren.

Imports System
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 'Main


        '**************************************************
        ' 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 'MyPeekCompleted

End Class 'MyNewQueue

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

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

package MyProject; 

import System.*;
import System.Messaging.*;

/// <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(String[] args)
    {
        // Create an instance of MessageQueue. Set its formatter.
        MessageQueue myQueue = new MessageQueue(".\\myQueue");
        myQueue.set_Formatter(new XmlMessageFormatter(new Type[]
            { String.class.ToType() }));
        // Add an event handler for the PeekCompleted event.
        myQueue.add_PeekCompleted(new PeekCompletedEventHandler(MyPeekCompleted));
        // Begin the asynchronous peek operation.
        myQueue.BeginPeek();
        // Do other work on the current thread.
        return;
    } //main

    //**************************************************
    // 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.get_AsyncResult());
        // Display message information on the screen.
        Console.WriteLine("Message: " + (String)(m.get_Body()));
        // Restart the asynchronous peek operation.
        mq.BeginPeek();
        return;
    } //MyPeekCompleted
} //MyNewQueue

.NET Framework-Sicherheit

• Volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer. Dieser Member kann von nur teilweise vertrauenswürdigem Code nicht verwendet werden. Weitere Informationen finden Sie unter .

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0

Siehe auch

Referenz

MessageQueue-Klasse
MessageQueue-Member
System.Messaging-Namespace
BeginPeek
PeekCompleted