PeekCompletedEventArgs-Klasse

Stellt Daten für das PeekCompleted-Ereignis bereit. Beim Aufruf eines Ereignishandlers durch die asynchrone Leseanweisung wird eine Instanz dieser Klasse an den Handler übergeben.

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

Syntax

'Declaration
Public Class PeekCompletedEventArgs
    Inherits EventArgs
'Usage
Dim instance As PeekCompletedEventArgs

public class PeekCompletedEventArgs : EventArgs

public ref class PeekCompletedEventArgs : public EventArgs

public class PeekCompletedEventArgs extends EventArgs

public class PeekCompletedEventArgs extends EventArgs

Hinweise

Wenn Sie Ereignisbenachrichtigungen zum asynchronen Lesen (reine Leseanweisung ohne Entfernen) von Nachrichten aus einer Warteschlange verwenden, müssen Sie eine Methode erstellen, die die Nachrichtenverarbeitung übernimmt. Zum Starten der asynchronen Verarbeitung muss im Code BeginPeek aufgerufen werden. Nach dem Lesen einer Nachricht wird die Anwendung durch das PeekCompleted-Ereignis benachrichtigt. Eine Instanz von PeekCompletedEventArgs wird an den Ereignisdelegaten übergeben, der den Ereignishandler aufruft. Die dem PeekCompleted-Ereignis zugeordneten Daten sind im AsyncResult-Parameter des Delegaten enthalten.

Es gibt zwei Benachrichtigungsmöglichkeiten bei Abschluss der Ereignisbehandlung: die Ereignisbenachrichtigung und Rückrufe. Das PeekCompletedEventArgs wird nur bei der Ereignisbenachrichtigung verwendet. Weitere Informationen über Rückrufe und die Ereignisbenachrichtigung finden Sie in MSDN unter "Events vs. Callbacks" (nur auf Englisch verügbar).

Das PeekCompletedEventArgs ermöglicht über den Message-Member einen Zugriff auf die Meldung, die den Abschluss des asynchronen Lesevorgangs initiiert hat. Es handelt sich hierbei um einen alternativen Nachrichtenzugriff (ähnlich einem Aufruf von MessageQueue.EndPeek).

Beispiel

Im folgenden Beispiel wird ein Handler für das PeekCompleted-Ereignis erstellt und dem Ereignisdelegaten über den PeekCompletedEventHandler zugeordnet. Der Ereignishandler MyPeekCompleted sieht eine Meldung ein und gibt ihre Bezeichnung an den Bildschirm aus.

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

Vererbungshierarchie

System.Object
   System.EventArgs
    System.Messaging.PeekCompletedEventArgs

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

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

PeekCompletedEventArgs-Member
System.Messaging-Namespace
MessageQueue-Klasse
PeekCompletedEventHandler
MessageQueue.PeekCompleted-Ereignis
BeginPeek
EndPeek
Message-Klasse