PeekCompletedEventArgs PeekCompletedEventArgs PeekCompletedEventArgs PeekCompletedEventArgs Class

Definition

Stellt Daten für das PeekCompleted-Ereignis bereit.Provides data for the PeekCompleted event. Beim Aufruf eines Ereignishandlers durch die asynchrone Leseanweisung wird eine Instanz dieser Klasse an den Handler übergeben.When your asynchronous peek operation calls an event handler, an instance of this class is passed to the handler.

public ref class PeekCompletedEventArgs : EventArgs
public class PeekCompletedEventArgs : EventArgs
type PeekCompletedEventArgs = class
    inherit EventArgs
Public Class PeekCompletedEventArgs
Inherits EventArgs
Vererbung
PeekCompletedEventArgsPeekCompletedEventArgsPeekCompletedEventArgsPeekCompletedEventArgs

Beispiele

Im folgenden Codebeispiel wird PeekCompleted PeekCompletedEventHandlerein Ereignishandler für das-Ereignis erstellt und mit dem Ereignis Delegaten verknüpft.The following code example creates an event handler for the PeekCompleted event and associates it with the event delegate by using the PeekCompletedEventHandler. Der Ereignishandler MyPeekCompleted,, sieht eine Meldung aus und schreibt seine Bezeichnung auf den Bildschirm.The event handler, MyPeekCompleted, peeks a message and writes its label to the screen.

#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 die Ereignis Benachrichtigung verwenden, um Nachrichten asynchron aus der Warteschlange zu lesen (ohne Sie zu entfernen), müssen Sie eine Methode erstellen, die die Nachrichtenverarbeitung verarbeitet.When you use event notification to peek (read without removing) messages asynchronously from the queue, you must create a method that handles your message processing. Der Code muss aufzurufen BeginPeek , um die asynchrone Verarbeitung zu starten.Your code must call BeginPeek to begin the asynchronous processing. Wenn eine Nachricht mit einem beliebigen Wert angezeigt wird, wird die Anwendung über PeekCompleted das Ereignis benachrichtigt.When a message is peeked, your application is notified through the PeekCompleted event. Eine Instanz von PeekCompletedEventArgs wird an den Ereignis Delegaten, der den Ereignishandler aufruft, übermittelt.An instance of PeekCompletedEventArgs is passed into the event delegate that calls your event handler. Die dem PeekCompleted Ereignis zugeordneten Daten sind im- AsyncResult Parameter des Delegaten enthalten.The data associated with the PeekCompleted event is contained in the delegate's AsyncResult parameter.

Es gibt zwei Möglichkeiten, eine Benachrichtigung über den Abschluss des Ereignisses bereitzustellen: Ereignis Benachrichtigung und Rückrufe.There are two ways to provide notification of event completion: event notification and callbacks. PeekCompletedEventArgswird nur bei der Ereignis Benachrichtigung verwendet.PeekCompletedEventArgs is used only with event notification. Informationen zum Vergleich von Rückrufen und Ereignis Benachrichtigungen finden Sie unter "Ereignisse im Vergleich zu Rückrufe "auf MSDN.For information comparing callbacks and event notification, see "Events vs. Callbacks" on MSDN.

PeekCompletedEventArgsermöglicht den Zugriff auf die Nachricht, die das Ende des asynchronen Peek-Vorgangs durch den Message -Member initiiert hat.PeekCompletedEventArgs provides access to the message that initiated the end of the asynchronous peek operation, through the Message member. Dies ist ein alternativer Zugriff auf die Nachricht und verhält sich ähnlich wie ein Aufrufen von MessageQueue.EndPeek.This is an alternate access to the message, and behaves much the same as a call to MessageQueue.EndPeek.

Eigenschaften

AsyncResult AsyncResult AsyncResult AsyncResult

Ruft das Ergebnis der angeforderten asynchronen Operation ab oder legt dieses fest.Gets or sets the result of the asynchronous operation requested.

Message Message Message Message

Ruft die der asynchronen Leseanweisung zugeordnete Nachricht ab.Gets the message associated with the asynchronous peek operation.

Methoden

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Gilt für:

Siehe auch