MessageQueue.EndPeek(IAsyncResult) Metoda

Definicja

Przestrzeń nazw:

System.Messaging

Zestaw:

System.Messaging.dll

Kończy określoną operację asynchronicznego wglądu.

public:
 System::Messaging::Message ^ EndPeek(IAsyncResult ^ asyncResult);

public System.Messaging.Message EndPeek (IAsyncResult asyncResult);

member this.EndPeek : IAsyncResult -> System.Messaging.Message

Public Function EndPeek (asyncResult As IAsyncResult) As Message

Parametry

asyncResult

IAsyncResult

Element IAsyncResult identyfikujący operację asynchronicznego wglądu do zakończenia i z której ma być pobierany wynik końcowy.

Zwraca

Message

Operacja Message asynchroniczna skojarzona z ukończoną operacją asynchroniczną.

Wyjątki

ArgumentNullException

Parametr asyncResult ma wartość null.

ArgumentException

Składnia parametru asyncResult jest nieprawidłowa.

MessageQueueException

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu tworzy procedurę obsługi zdarzeń o nazwie MyPeekCompleted, dołącza ją do PeekCompleted delegata programu obsługi zdarzeń i wywołuje BeginPeek metodę inicjowania asynchronicznej operacji wglądu w kolejkę znajdującą się w ścieżce ".\myQueue". Po wystąpieniu PeekCompleted zdarzenia przykład wyświetla komunikat i zapisuje jego treść na ekranie. W przykładzie zostanie ponownie wywołana BeginPeek metoda inicjowania nowej operacji asynchronicznej wglądu.

#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

Po wywołaniu EndPeek(IAsyncResult) zdarzenia PeekCompleted kończy operację zainicjowaną przez wywołanieBeginPeek. W tym EndPeek(IAsyncResult) celu podejrzy komunikat.

BeginPeek Program może określić limit czasu, co powoduje PeekCompleted , że zdarzenie jest zgłaszane, jeśli limit czasu wystąpi przed wyświetleniem komunikatu w kolejce. W przypadku przekroczenia limitu czasu bez komunikatu przychodzącego do kolejki kolejne wywołanie EndPeek(IAsyncResult) zgłasza wyjątek.

EndPeek(IAsyncResult) element służy do odczytywania komunikatu, który spowodował PeekCompleted wywołanie zdarzenia.

Jeśli chcesz nadal asynchronicznie wyświetlać komunikaty, możesz ponownie wywołać metodę BeginPeek po wywołaniu metody EndPeek(IAsyncResult).

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Nazwa komputera lokalnego i bezpośredniego formatu	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i bezpośredniego formatu	Tak

Zobacz też

• BeginPeek()
• PeekCompleted