PeekCompletedEventArgs Klasa

Definicja

Przestrzeń nazw:

System.Messaging

Zestaw:

System.Messaging.dll

Udostępnia dane dla zdarzenia PeekCompleted. Gdy asynchroniczna operacja wglądu wywołuje procedurę obsługi zdarzeń, wystąpienie tej klasy jest przekazywane do programu obsługi.

public ref class PeekCompletedEventArgs : EventArgs

public class PeekCompletedEventArgs : EventArgs

type PeekCompletedEventArgs = class
    inherit EventArgs

Public Class PeekCompletedEventArgs
Inherits EventArgs

Dziedziczenie

Object

EventArgs

PeekCompletedEventArgs

Przykłady

Poniższy przykład kodu tworzy procedurę obsługi zdarzeń dla PeekCompleted zdarzenia i kojarzy je z delegatem zdarzenia przy użyciu elementu PeekCompletedEventHandler. Program obsługi zdarzeń, , MyPeekCompletedwyświetla komunikat i zapisuje etykietę na ekranie.

#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

Uwagi

W przypadku użycia powiadomienia o zdarzeniach do wglądu (odczytywania bez usuwania) komunikatów asynchronicznie z kolejki należy utworzyć metodę, która obsługuje przetwarzanie komunikatów. Kod musi wywołać BeginPeek metodę , aby rozpocząć przetwarzanie asynchroniczne. Po wyświetleniu komunikatu aplikacja jest powiadamiana za pośrednictwem PeekCompleted zdarzenia. Wystąpienie klasy jest przekazywane do delegata PeekCompletedEventArgs zdarzeń, który wywołuje procedurę obsługi zdarzeń. Dane skojarzone ze zdarzeniem PeekCompleted są zawarte w parametrze delegata AsyncResult .

Istnieją dwa sposoby dostarczania powiadomień o zakończeniu zdarzenia: powiadomienia o zdarzeniach i wywołania zwrotne. PeekCompletedEventArgs jest używany tylko z powiadomieniem o zdarzeniu. Aby uzyskać informacje dotyczące porównywania wywołań zwrotnych i powiadomień o zdarzeniach, zobacz "Zdarzenia a wywołania zwrotne" w witrynie MSDN.

PeekCompletedEventArgs zapewnia dostęp do komunikatu, który zainicjował koniec operacji asynchronicznej wglądu za pośrednictwem elementu Message członkowskiego. Jest to alternatywny dostęp do wiadomości i zachowuje się tak samo jak wywołanie metody MessageQueue.EndPeek.

Właściwości

AsyncResult	Pobiera lub ustawia wynik żądanej operacji asynchronicznej.
Message	Pobiera komunikat skojarzony z operacją asynchronicznego wglądu.

Metody

Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)

Zobacz też

• MessageQueue
• PeekCompletedEventHandler
• PeekCompleted
• BeginPeek()
• EndPeek(IAsyncResult)
• Message