Freigeben über

MessageQueue.BeginPeek Methode

  • Referenz

Definition

Namespace:
System.Messaging
Assembly:
System.Messaging.dll

Initiiert einen asynchronen Lesevorgang, indem Message Queuing angewiesen wird, mit dem Einsehen einer Meldung zu beginnen und nach Abschluss des Vorgangs den Ereignishandler zu benachrichtigen.

Überlädt

BeginPeek(TimeSpan, Object, AsyncCallback)

Initiiert einen asynchronen Lesevorgang mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginPeek(TimeSpan, Object)

Initiiert einen asynchronen Lesevorgang mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Initiiert einen asynchronen Lesevorgang, der über einen angegebenen Timeout verfügt und für den ein Cursor, eine Suchaktion und ein Zustandsobjekt festgelegt sind. Das Zustandsobjekt stellt für die Lebensdauer des Vorgangs zugeordnete Informationen bereit. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginPeek()

Diese Methode initiiert einen asynchronen Einsehvorgang ohne Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist.
BeginPeek(TimeSpan)

Diese Methode initiiert einen asynchronen Einsehvorgang mit einem bestimmten Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist oder ein Timeout auftritt.

BeginPeek(TimeSpan, Object, AsyncCallback)

Initiiert einen asynchronen Lesevorgang mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);
public IAsyncResult BeginPeek (TimeSpan timeout, object stateObject, AsyncCallback callback);
member this.BeginPeek : TimeSpan * obj * AsyncCallback -> IAsyncResult
Public Function BeginPeek (timeout As TimeSpan, stateObject As Object, callback As AsyncCallback) As IAsyncResult

Parameter

timeout
TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf eine verfügbare Meldung gewartet werden soll.

stateObject
Object

Ein von der Anwendung angegebenes Zustandsobjekt, das dem asynchronen Vorgang zugeordnete Informationen enthält.

callback
AsyncCallback

Der AsyncCallback, der die Benachrichtigung über den Abschluss des asynchronen Vorgangs erhält.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

ArgumentException

Der für den timeout-Parameter angegebene Wert ist nicht gültig.

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird ein asynchroner Einsehenvorgang erstellt. Das Codebeispiel sendet eine Nachricht an eine lokale Nachrichtenwarteschlange und ruft BeginPeek(TimeSpan, Object, AsyncCallback)dann auf, und übergibt: einen Timeoutwert von zehn Sekunden, eine eindeutige ganze Zahl, die diese bestimmte Nachricht identifiziert, und eine neue instance, AsyncCallback die den Ereignishandler identifiziert. MyPeekCompleted Wenn ein PeekCompleted Ereignis ausgelöst wird, sieht der Ereignishandler die Nachricht ein und schreibt den Nachrichtentext und den ganzzahligen Nachrichtenbezeichner auf den Bildschirm.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();      
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the PeekCompleted event.
void MyPeekCompleted(IAsyncResult^ asyncResult)
{
    // Connect to the queue.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

    // End the asynchronous peek operation.
    Message^ msg = queue->EndPeek(asyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", asyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    // Receive the message. This will remove the message from the queue.
    msg = queue->Receive(TimeSpan::FromSeconds(10.0));

    queue->Close();
}

int main()
{
    // Represents a state object associated with each message.
    int messageNumber = 0;

    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    CreateQueue(".\\exampleQueue", false);

    // Connect to a queue on the local computer.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

    // Send a message to the queue.
    queue->Send("Example Message");

    // Begin the asynchronous peek operation.
    queue->BeginPeek(TimeSpan::FromSeconds(10.0), messageNumber++,
        gcnew AsyncCallback(MyPeekCompleted));

    // Simulate doing other work on the current thread.
    System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));

    queue->Close();
}

using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous peek operation.
        queue.BeginPeek(TimeSpan.FromSeconds(10.0), messageNumber++,
            new AsyncCallback(MyPeekCompleted));

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the PeekCompleted event.
    private static void MyPeekCompleted(IAsyncResult asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // End the asynchronous peek operation.
        Message msg = queue.EndPeek(asyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}", (int)asyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);

        // Receive the message. This will remove the message from the queue.
        msg = queue.Receive(TimeSpan.FromSeconds(10.0));
    }
}

Hinweise

Wenn Sie diese Überladung verwenden, wird der im Rückrufparameter angegebene Rückruf direkt aufgerufen, wenn eine Nachricht in der Warteschlange verfügbar ist oder das angegebene Zeitintervall abgelaufen ist. Das PeekCompleted Ereignis wird nicht ausgelöst. Die anderen Überladungen von BeginPeek basieren auf dieser Komponente, um das Ereignis auszulösen PeekCompleted .

PeekCompleted wird auch ausgelöst, wenn bereits eine Nachricht in der Warteschlange vorhanden ist.

Die BeginPeek -Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginPeek asynchron ist, können Sie sie aufrufen, um die Warteschlange einzusehen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie Peek die -Methode, um die Warteschlange synchron einzusehen.

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

BeginPeek gibt einen IAsyncResult zurück, der den asynchronen Vorgang identifiziert, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie ihn in der Regel erst verwenden, wenn EndPeek(IAsyncResult) aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob auf den Abschluss aller Vorgänge oder vorgänge gewartet werden soll. In diesem Fall verwenden Sie die AsyncWaitHandle -Eigenschaft von IAsyncResult , um den abgeschlossenen Vorgang zu identifizieren.

Das Zustandsobjekt ordnet dem Vorgang Zustandsinformationen zu. Wenn Sie beispielsweise mehrmals aufrufen BeginPeek , um mehrere Vorgänge zu initiieren, können Sie jeden Vorgang über ein separates Zustandsobjekt identifizieren, das Sie definieren.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

BeginPeek(TimeSpan, Object)

Initiiert einen asynchronen Lesevorgang mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout, System::Object ^ stateObject);
public IAsyncResult BeginPeek (TimeSpan timeout, object stateObject);
member this.BeginPeek : TimeSpan * obj -> IAsyncResult
Public Function BeginPeek (timeout As TimeSpan, stateObject As Object) As IAsyncResult

Parameter

timeout
TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf eine verfügbare Meldung gewartet werden soll.

stateObject
Object

Ein von der Anwendung angegebenes Zustandsobjekt, das dem asynchronen Vorgang zugeordnete Informationen enthält.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

ArgumentException

Der für den timeout-Parameter angegebene Wert ist nicht gültig.

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird ein asynchroner Einsehenvorgang unter Verwendung des Warteschlangenpfads ".\myQueue" erstellt. Er erstellt einen Ereignishandler und MyPeekCompletedfügt ihn an den PeekCompleted Ereignishandlerdelegaten an. BeginPeek wird mit einem Timeout von einer Minute aufgerufen. Jeder Aufruf von verfügt über BeginPeek eine eindeutige zugeordnete ganze Zahl, die diesen bestimmten Vorgang identifiziert. Wenn ein PeekCompleted Ereignis ausgelöst wird oder das Timeout abgelaufen ist, wird die Meldung abgerufen, sofern vorhanden, und ihr Text und der vorgangsspezifische ganzzahlige Bezeichner werden auf den Bildschirm geschrieben. Anschließend BeginPeek wird erneut aufgerufen, um einen neuen asynchronen Peek-Vorgang mit demselben Timeout und der zugeordneten ganzzahligen Zahl des gerade abgeschlossenen Vorgangs zu initiieren.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

   // Represents a state object associated with each message.
   static int messageNumber = 0;

   // Provides an event handler for the PeekCompleted
   // event.
   //
   static void MyPeekCompleted( Object^ source, PeekCompletedEventArgs^ asyncResult )
   {
      try
      {
         // 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, 
         // including the message number (state object).
         Console::WriteLine( "Message: {0} {1}", asyncResult->AsyncResult->AsyncState, static_cast<String^>(m->Body) );

         // Restart the asynchronous peek operation, with the 
         // same time-out.
         mq->BeginPeek( TimeSpan(0,1,0), messageNumber++ );
      }
      catch ( MessageQueueException^ e ) 
      {
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( e );
         }

         // Handle other sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};


// Provides an entry point into the application.
//         
// This example performs asynchronous peek operation
// processing.
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 with a timeout 
   // of one minute.
   myQueue->BeginPeek( TimeSpan(0,1,0), MyNewQueue::messageNumber++ );

   // 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 MyNewQueue3
    {
        // Represents a state object associated with each message.
        static int messageNumber = 0;

        //**************************************************
        // 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 with a time-out
            // of one minute.
            myQueue.BeginPeek(new TimeSpan(0, 1, 0), messageNumber++);

            // Do other work on the current thread.

            return;
        }

        //**************************************************
        // Provides an event handler for the PeekCompleted
        // event.
        //**************************************************

        private static void MyPeekCompleted(Object source,
            PeekCompletedEventArgs asyncResult)
        {
            try
            {
                // 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,
                // including the message number (state object).
                Console.WriteLine("Message: " +
                    (int)asyncResult.AsyncResult.AsyncState + " "
                    + (string)m.Body);

                // Restart the asynchronous peek operation, with the
                // same time-out.
                mq.BeginPeek(new TimeSpan(0, 1, 0), messageNumber++);
            }

            catch (MessageQueueException e)
            {
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine(e.ToString());
                }

                // Handle other sources of MessageQueueException.
            }

            // Handle other exceptions.

            return;
        }
    }
}

Imports System.Messaging


   
' Provides a container class for the example.

Public Class MyNewQueue

        ' Represents a state object associated with each message.
        Private Shared messageNumber As Integer = 0



        ' 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 with a time-out 
            ' of one minute.
            myQueue.BeginPeek(New TimeSpan(0, 1, 0), messageNumber)
            messageNumber += 1

            ' 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)

            Try
                ' 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, 
                ' including(the) message number (state object).
                Console.WriteLine(("Message: " + _
                    CInt(asyncResult.AsyncResult.AsyncState) + _
                    " " + CStr(m.Body)))

                ' Restart the asynchronous peek operation, with the 
                ' same time-out.
                mq.BeginPeek(New TimeSpan(0, 1, 0), messageNumber)
                messageNumber += 1


            Catch e As MessageQueueException

                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    Console.WriteLine(e.ToString())

                    ' Handle other sources of MessageQueueException.

                End If

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Hinweise

Bei der asynchronen Verarbeitung wird BeginPeek das PeekCompleted Ereignis ausgelöst, wenn eine Nachricht in der Warteschlange verfügbar ist oder das angegebene Zeitintervall abgelaufen ist.

PeekCompleted wird auch ausgelöst, wenn bereits eine Nachricht in der Warteschlange vorhanden ist.

Verwenden Sie diese Überladung, um dem Vorgang Informationen zuzuordnen, die während der gesamten Lebensdauer des Vorgangs beibehalten werden. Der Ereignishandler kann auf diese Informationen zugreifen, indem er die AsyncState -Eigenschaft des -Objekts betrachtet, die IAsyncResult dem Vorgang zugeordnet ist.

Um zu verwenden BeginPeek, erstellen Sie einen Ereignishandler, der die Ergebnisse des asynchronen Vorgangs verarbeitet, und ordnen Sie ihn Ihrem Ereignisdelegat zu. BeginPeek initiiert einen asynchronen Einsehenvorgang; wird MessageQueue über das Auslösen des PeekCompleted Ereignisses benachrichtigt, wenn eine Nachricht in der Warteschlange eingeht. Der MessageQueue kann dann auf die Nachricht zugreifen, indem es aufruft EndPeek(IAsyncResult) oder das Ergebnis mithilfe von abruft PeekCompletedEventArgs.

Die BeginPeek -Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginPeek asynchron ist, können Sie sie aufrufen, um die Warteschlange einzusehen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie Peek die -Methode, um die Warteschlange synchron einzusehen.

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

BeginPeek gibt einen IAsyncResult zurück, der den asynchronen Vorgang identifiziert, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie ihn in der Regel erst verwenden, wenn EndPeek(IAsyncResult) aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob auf den Abschluss aller Vorgänge oder vorgänge gewartet werden soll. In diesem Fall verwenden Sie die AsyncWaitHandle -Eigenschaft von IAsyncResult , um den abgeschlossenen Vorgang zu identifizieren.

Diese Überladung gibt ein Timeout und ein Zustandsobjekt an. Wenn das durch den timeout Parameter angegebene Intervall abläuft, löst diese Komponente das PeekCompleted -Ereignis aus. Da keine Nachricht vorhanden ist, löst ein späterer Aufruf von EndPeek(IAsyncResult) eine Ausnahme aus.

Das Zustandsobjekt ordnet dem Vorgang Zustandsinformationen zu. Wenn Sie beispielsweise mehrmals aufrufen BeginPeek , um mehrere Vorgänge zu initiieren, können Sie jeden Vorgang über ein separates Zustandsobjekt identifizieren, das Sie definieren. Eine Abbildung dieses Szenarios finden Sie im Abschnitt Beispiel.

Sie können auch das Statusobjekt verwenden, um Informationen über Prozessthreads hinweg zu übergeben. Wenn ein Thread gestartet wird, sich der Rückruf jedoch in einem asynchronen Szenario in einem anderen Thread befindet, wird das Zustandsobjekt gemarshallt und zusammen mit Informationen aus dem Ereignis zurückgegeben.

Wenn CanRead ist false, wird das Abschlussereignis ausgelöst, aber beim Aufrufen EndPeek(IAsyncResult)von wird eine Ausnahme ausgelöst.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Initiiert einen asynchronen Lesevorgang, der über einen angegebenen Timeout verfügt und für den ein Cursor, eine Suchaktion und ein Zustandsobjekt festgelegt sind. Das Zustandsobjekt stellt für die Lebensdauer des Vorgangs zugeordnete Informationen bereit. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::PeekAction action, System::Object ^ state, AsyncCallback ^ callback);
public IAsyncResult BeginPeek (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.PeekAction action, object state, AsyncCallback callback);
member this.BeginPeek : TimeSpan * System.Messaging.Cursor * System.Messaging.PeekAction * obj * AsyncCallback -> IAsyncResult
Public Function BeginPeek (timeout As TimeSpan, cursor As Cursor, action As PeekAction, state As Object, callback As AsyncCallback) As IAsyncResult

Parameter

timeout
TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf eine verfügbare Meldung gewartet werden soll.

cursor
Cursor

Ein Cursor, der eine bestimmte Position in der Meldungswarteschlange beibehält.

action
PeekAction

Einer der PeekAction-Werte. Gibt an, ob die aktuelle oder die folgende Meldung in der Warteschlange eingesehen wird.

state
Object

Ein von der Anwendung angegebenes Zustandsobjekt, das dem asynchronen Vorgang zugeordnete Informationen enthält.

callback
AsyncCallback

Der AsyncCallback, der die Benachrichtigung über den Abschluss des asynchronen Vorgangs erhält.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

ArgumentOutOfRangeException

Für den action-Parameter wurde ein anderer Wert als PeekAction.Current oder PeekAction.Next angegeben.

ArgumentNullException

Der cursor-Parameter ist null.

ArgumentException

Der für den timeout-Parameter angegebene Wert ist nicht gültig.

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Hinweise

Wenn Sie diese Überladung verwenden, wird der im Rückrufparameter angegebene Rückruf direkt aufgerufen, wenn eine Nachricht in der Warteschlange verfügbar ist oder das angegebene Zeitintervall abgelaufen ist. Das PeekCompleted Ereignis wird nicht ausgelöst. Die anderen Überladungen von BeginPeek basieren auf dieser Komponente, um das Ereignis auszulösen PeekCompleted .

PeekCompleted wird auch ausgelöst, wenn bereits eine Nachricht in der Warteschlange vorhanden ist.

Die BeginPeek -Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginPeek asynchron ist, können Sie sie aufrufen, um die Warteschlange einzusehen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie Peek die -Methode, um die Warteschlange synchron einzusehen.

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

BeginPeek gibt einen IAsyncResult zurück, der den asynchronen Vorgang identifiziert, der von der -Methode gestartet wurde. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie ihn in der Regel erst verwenden, wenn EndPeek(IAsyncResult) aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob auf den Abschluss aller Vorgänge oder vorgänge gewartet werden soll. Verwenden Sie in diesem Fall die AsyncWaitHandle -Eigenschaft von IAsyncResult , um den abgeschlossenen Vorgang zu identifizieren.

Das Zustandsobjekt ordnet dem Vorgang Zustandsinformationen zu. Wenn Sie beispielsweise mehrmals aufrufen BeginPeek , um mehrere Vorgänge zu initiieren, können Sie jeden Vorgang über ein separates Zustandsobjekt identifizieren, das Sie definieren.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

BeginPeek()

Diese Methode initiiert einen asynchronen Einsehvorgang ohne Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist.

public:
 IAsyncResult ^ BeginPeek();
public IAsyncResult BeginPeek ();
member this.BeginPeek : unit -> IAsyncResult
Public Function BeginPeek () As IAsyncResult

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird ein Ereignishandler namens MyPeekCompletederstellt, an den PeekCompleted Ereignishandlerdelegaten angefügt und aufgerufen BeginPeek , um einen asynchronen Einsehenvorgang für die Warteschlange zu initiieren, die sich unter dem Pfad ".\myQueue" befindet. Wenn ein PeekCompleted Ereignis ausgelöst wird, zeigt das Beispiel die Nachricht an und schreibt ihren Text auf den Bildschirm. Im Beispiel wird dann erneut aufgerufen BeginPeek , um einen neuen asynchronen Einsehenvorgang zu initiieren.

#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

Bei der asynchronen Verarbeitung verwenden BeginPeek Sie, um das Ereignis auszulösen PeekCompleted , wenn eine Nachricht in der Warteschlange verfügbar wird.

PeekCompleted wird auch ausgelöst, wenn bereits eine Nachricht in der Warteschlange vorhanden ist.

Um zu verwenden BeginPeek, erstellen Sie einen Ereignishandler, der die Ergebnisse des asynchronen Vorgangs verarbeitet, und ordnen Sie ihn Ihrem Ereignisdelegat zu. BeginPeek initiiert einen asynchronen Einsehenvorgang; wird MessageQueue über das Auslösen des PeekCompleted Ereignisses benachrichtigt, wenn eine Nachricht in der Warteschlange eingeht. Der MessageQueue kann dann auf die Nachricht zugreifen, indem es aufruft EndPeek(IAsyncResult) oder das Ergebnis mithilfe von abruft PeekCompletedEventArgs.

Die BeginPeek -Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginPeek asynchron ist, können Sie sie aufrufen, um die Warteschlange einzusehen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie Peek die -Methode, um die Warteschlange synchron einzusehen.

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

Der IAsyncResult , der zurückgibt, BeginPeek identifiziert den asynchronen Vorgang, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie ihn in der Regel erst verwenden, wenn EndPeek(IAsyncResult) aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob auf den Abschluss aller Vorgänge oder vorgänge gewartet werden soll. In diesem Fall verwenden Sie die AsyncWaitHandle -Eigenschaft von IAsyncResult , um den abgeschlossenen Vorgang zu identifizieren.

Wenn CanRead ist false, wird das Abschlussereignis ausgelöst, aber beim Aufrufen EndPeek(IAsyncResult)von wird eine Ausnahme ausgelöst.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

BeginPeek(TimeSpan)

Diese Methode initiiert einen asynchronen Einsehvorgang mit einem bestimmten Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist oder ein Timeout auftritt.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout);
public IAsyncResult BeginPeek (TimeSpan timeout);
member this.BeginPeek : TimeSpan -> IAsyncResult
Public Function BeginPeek (timeout As TimeSpan) As IAsyncResult

Parameter

timeout
TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf eine verfügbare Meldung gewartet werden soll.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das die übermittelte asynchrone Anforderung bezeichnet.

Ausnahmen

ArgumentException

Der für den timeout-Parameter angegebene Wert ist nicht gültig.

MessageQueueException

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird ein asynchroner Einsehenvorgang unter Verwendung des Warteschlangenpfads ".\myQueue" erstellt. Er erstellt einen Ereignishandler und MyPeekCompletedfügt ihn an den PeekCompleted Ereignishandlerdelegaten an. BeginPeek wird mit einem Timeout von einer Minute aufgerufen, um den asynchronen Einsehenvorgang zu initiieren. Wenn ein PeekCompleted Ereignis ausgelöst wird oder das Timeout abläuft, wird die Nachricht abgerufen, sofern vorhanden, und ihr Text wird auf den Bildschirm geschrieben. Anschließend BeginPeek wird erneut aufgerufen, um einen neuen asynchronen Einsehenvorgang mit demselben Timeout zu initiieren.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
   static void MyPeekCompleted( Object^ source, PeekCompletedEventArgs^ asyncResult )
   {      try
      {
         // 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, with the 
         // same time-out.
         mq->BeginPeek( TimeSpan(0,1,0) );
      }
      catch ( MessageQueueException^ e ) 
      {
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( e );
         }

         // Handle other sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};

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 with a timeout 
   // of one minute.
   myQueue->BeginPeek( TimeSpan(0,1,0) );

   // 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 MyNewQueue2
    {
        //**************************************************
        // 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 with a time-out
            // of one minute.
            myQueue.BeginPeek(new TimeSpan(0, 1, 0));

            // Do other work on the current thread.

            return;
        }

        //**************************************************
        // Provides an event handler for the PeekCompleted
        // event.
        //**************************************************

        private static void MyPeekCompleted(Object source,
            PeekCompletedEventArgs asyncResult)
        {
            try
            {
                // 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, with the
                // same time-out.
                mq.BeginPeek(new TimeSpan(0, 1, 0));
            }

            catch (MessageQueueException e)
            {
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine(e.ToString());
                }

                // Handle other sources of MessageQueueException.
            }

            // Handle other exceptions.

            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 with a time-out 
            ' of one minute.
            myQueue.BeginPeek(New TimeSpan(0, 1, 0))

            ' 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)

            Try
                ' 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, with the 
                ' same time-out.
                mq.BeginPeek(New TimeSpan(0, 1, 0))

            Catch e As MessageQueueException

                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    Console.WriteLine(e.ToString())

                    ' Handle other sources of MessageQueueException.
                End If

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Hinweise

Bei der asynchronen Verarbeitung wird BeginPeek das PeekCompleted Ereignis ausgelöst, wenn eine Nachricht in der Warteschlange verfügbar ist oder das angegebene Zeitintervall abgelaufen ist.

PeekCompleted wird auch ausgelöst, wenn bereits eine Nachricht in der Warteschlange vorhanden ist.

Um zu verwenden BeginPeek, erstellen Sie einen Ereignishandler, der die Ergebnisse des asynchronen Vorgangs verarbeitet, und ordnen Sie ihn Ihrem Ereignisdelegat zu. BeginPeek initiiert einen asynchronen Einsehenvorgang; wird MessageQueue über das Auslösen des PeekCompleted Ereignisses benachrichtigt, wenn eine Nachricht in der Warteschlange eingeht. Der MessageQueue kann dann auf die Nachricht zugreifen, indem es aufruft EndPeek(IAsyncResult) oder das Ergebnis mithilfe von abruft PeekCompletedEventArgs.

Die BeginPeek -Methode gibt sofort zurück, aber der asynchrone Vorgang wird erst abgeschlossen, wenn der Ereignishandler aufgerufen wird.

Da BeginPeek asynchron ist, können Sie sie aufrufen, um die Warteschlange einzusehen, ohne den aktuellen Ausführungsthread zu blockieren. Verwenden Sie Peek die -Methode, um die Warteschlange synchron einzusehen.

Nach Abschluss eines asynchronen Vorgangs können Sie oder BeginReceive erneut im Ereignishandler aufrufenBeginPeek, um weiterhin Benachrichtigungen zu erhalten.

Der IAsyncResult , der zurückgibt, BeginPeek identifiziert den asynchronen Vorgang, den die Methode gestartet hat. Sie können dies IAsyncResult während der gesamten Lebensdauer des Vorgangs verwenden, obwohl Sie ihn in der Regel erst verwenden, wenn EndPeek(IAsyncResult) aufgerufen wird. Wenn Sie jedoch mehrere asynchrone Vorgänge starten, können Sie deren IAsyncResult Werte in einem Array platzieren und angeben, ob auf den Abschluss aller Vorgänge oder vorgänge gewartet werden soll. In diesem Fall verwenden Sie die AsyncWaitHandle -Eigenschaft von IAsyncResult , um den abgeschlossenen Vorgang zu identifizieren.

Diese Überladung gibt ein Timeout an. Wenn das durch den timeout Parameter angegebene Intervall abläuft, löst diese Komponente das PeekCompleted -Ereignis aus. Da keine Nachricht vorhanden ist, löst ein späterer Aufruf von EndPeek(IAsyncResult) eine Ausnahme aus.

Wenn CanRead ist false, wird das Abschlussereignis ausgelöst, aber beim Aufrufen EndPeek(IAsyncResult)von wird eine Ausnahme ausgelöst.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Threadsicherheit

Die -Methode ist nicht threadsicher.