MessageQueue.EndPeek(IAsyncResult) Yöntem

Tanım

Ad Alanı:

System.Messaging

Bütünleştirilmiş Kod:

System.Messaging.dll

Belirtilen zaman uyumsuz göz atma işlemini tamamlar.

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

Parametreler

asyncResult

IAsyncResult

IAsyncResult Bitmesi ve bitiş sonucunun alınması için zaman uyumsuz özet işlemini tanımlayan.

Döndürülenler

Message

Tamamlanan Message zaman uyumsuz işlemle ilişkili.

Özel durumlar

ArgumentNullException

asyncResult parametresidirnull.

ArgumentException

Parametrenin asyncResult söz dizimi geçerli değil.

MessageQueueException

Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneği adlı MyPeekCompletedbir olay işleyicisi oluşturur, bunu olay işleyici temsilcisine PeekCompleted ekler ve ".\myQueue" yolunda bulunan kuyrukta zaman uyumsuz bir özet işlemi başlatmak için çağrı BeginPeek yapar. Bir PeekCompleted olay tetiklendiğinde, örnek iletiye göz atar ve gövdesini ekrana yazar. Örnek daha sonra yeni bir zaman uyumsuz özet işlemi başlatmak için yeniden çağırır BeginPeek .

#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

Açıklamalar

PeekCompleted Olay tetiklendiğinde, EndPeek(IAsyncResult) çağrı tarafından BeginPeek başlatılan işlemi tamamlar. Bunu yapmak için iletiye EndPeek(IAsyncResult) göz atın.

BeginPeek bir zaman aşımı belirtebilir ve bu da zaman aşımının kuyrukta bir ileti görüntülenmeden önce gerçekleşmesi durumunda olayın tetiklenmelerine neden olur PeekCompleted . Kuyruğa ileti gelmeden zaman aşımı oluştuğunda, sonraki bir çağrı EndPeek(IAsyncResult) özel durum oluşturur.

EndPeek(IAsyncResult) , olayın tetik edilmesine neden PeekCompleted olan iletiyi okumak için kullanılır.

İletileri zaman uyumsuz olarak göz atmaya devam etmek istiyorsanız, çağrısı EndPeek(IAsyncResult)yaptıktan sonra yeniden çağırabilirsinizBeginPeek.

Aşağıdaki tabloda bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu	Kullanılabilir
Yerel bilgisayar	Yes
Yerel bilgisayar ve doğrudan biçim adı	Yes
Uzak bilgisayar	No
Uzak bilgisayar ve doğrudan biçim adı	Yes

Ayrıca bkz.

• BeginPeek()
• PeekCompleted