PeekCompletedEventArgs Klasse

Referenz

Definition

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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.

public ref class PeekCompletedEventArgs : EventArgs

public class PeekCompletedEventArgs : EventArgs

type PeekCompletedEventArgs = class
    inherit EventArgs

Public Class PeekCompletedEventArgs
Inherits EventArgs

Vererbung: Object

EventArgs
PeekCompletedEventArgs

Beispiele

Im folgenden Codebeispiel wird ein Ereignishandler für das PeekCompleted Ereignis erstellt und mit PeekCompletedEventHandlerdem Ereignisdelegat verknüpft. Der Ereignishandler , MyPeekCompletedschaut sich eine Nachricht an und schreibt ihre Bezeichnung auf den Bildschirm.

#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 Sie ereignisbenachrichtigungen verwenden, um Nachrichten asynchron aus der Warteschlange anzuzeigen (ohne zu entfernen), müssen Sie eine Methode erstellen, die die Nachrichtenverarbeitung verarbeitet. Ihr Code muss aufgerufen BeginPeek werden, um mit der asynchronen Verarbeitung zu beginnen. Wenn eine Nachricht angezeigt wird, wird Ihre Anwendung über das PeekCompleted Ereignis benachrichtigt. Ein instance von PeekCompletedEventArgs wird an den Ereignisdelegat übergeben, der Ihren Ereignishandler aufruft. Die dem PeekCompleted Ereignis zugeordneten Daten sind im Parameter des AsyncResult Delegaten enthalten.

Es gibt zwei Möglichkeiten, Benachrichtigungen über den Abschluss des Ereignisses bereitzustellen: Ereignisbenachrichtigungen und Rückrufe. PeekCompletedEventArgs wird nur mit Ereignisbenachrichtigungen verwendet. Informationen zum Vergleichen von Rückrufen und Ereignisbenachrichtigungen finden Sie unter "Ereignisse im Vergleich zu Rückrufen" auf MSDN.

PeekCompletedEventArgs ermöglicht über den Member Zugriff auf die Nachricht, die das Ende des asynchronen Peek-Vorgangs Message initiiert hat. Dies ist ein alternativer Zugriff auf die Nachricht und verhält sich ähnlich wie ein Aufruf von MessageQueue.EndPeek.

Eigenschaften

AsyncResult	Ruft das Ergebnis der angeforderten asynchronen Operation ab oder legt dieses fest.
Message	Ruft die der asynchronen Leseanweisung zugeordnete Nachricht ab.

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Gilt für:

Freigeben über