MessageQueue.EndPeek(IAsyncResult) Metódus

Definíció

Névtér:

System.Messaging

Szerelvény:

System.Messaging.dll

Befejezi a megadott aszinkron betekintő műveletet.

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

Paraméterek

asyncResult

IAsyncResult

Az IAsyncResult aszinkron betekintő műveletet azonosítja, amely befejeződik, és amelyből lekéri a végeredményt.

Válaszok

Message

A Message befejezett aszinkron művelethez társított.

Kivételek

ArgumentNullException

A asyncResult paraméter a következő null: .

ArgumentException

A paraméter szintaxisa asyncResult érvénytelen.

MessageQueueException

Hiba történt a Message Queuing metódus elérésekor.

Példák

Az alábbi kódpéldában létrejön egy eseménykezelő neve MyPeekCompleted, csatolja azt az PeekCompleted eseménykezelő delegáltjának, és meghív BeginPeek egy aszinkron betekintő műveletet a ".\myQueue" útvonalon található üzenetsoron. Amikor egy PeekCompleted esemény létrejön, a példa betekint az üzenetbe, és a képernyőre írja a törzsét. A példa ezután ismét meghív BeginPeek egy új aszinkron betekintő műveletet.

#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

Megjegyzések

Az PeekCompleted esemény indításakor EndPeek(IAsyncResult) befejezi a hívás által BeginPeek kezdeményezett műveletet. Ehhez EndPeek(IAsyncResult) bepillantás az üzenetbe.

BeginPeek megadhatja az időtúllépést, ami miatt az PeekCompleted esemény akkor lép fel, ha az időtúllépés azelőtt történik, hogy egy üzenet megjelenik az üzenetsorban. Ha időtúllépés történik anélkül, hogy üzenet érkezik az üzenetsorba, egy későbbi hívás EndPeek(IAsyncResult) kivételt eredményez.

EndPeek(IAsyncResult) az eseményt kiváltó PeekCompleted üzenet olvasására szolgál.

Ha továbbra is aszinkron módon szeretné betekinteni az üzeneteket, hívás után BeginPeekismét hívhatEndPeek(IAsyncResult).

Az alábbi táblázat azt mutatja be, hogy ez a módszer elérhető-e különböző munkacsoport-módban.

Munkacsoport mód	Elérhető
Helyi számítógép	Igen
Helyi számítógép és közvetlen formátum neve	Igen
Távoli számítógép	No
Távoli számítógép és közvetlen formátum neve	Igen

Lásd még

• BeginPeek()
• PeekCompleted