MessageQueue.BeginPeek Methode

Definitie

Naamruimte:: System.Messaging

Assembly:: System.Messaging.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Start een asynchrone weergavebewerking door Message Queuing te vertellen een bericht te bekijken en de gebeurtenis-handler te waarschuwen wanneer u klaar bent.

Overloads

Name	Description
BeginPeek(TimeSpan, Object, AsyncCallback)	Start een asynchrone peek-bewerking met een opgegeven time-out en een opgegeven statusobject, dat gekoppelde informatie biedt gedurende de levensduur van de bewerking. Deze overbelasting ontvangt een melding via een callback van de identiteit van de gebeurtenis-handler voor de bewerking. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij of als er een time-out optreedt.
BeginPeek(TimeSpan, Object)	Start een asynchrone peek-bewerking met een opgegeven time-out en een opgegeven statusobject, dat gekoppelde informatie biedt gedurende de levensduur van de bewerking. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij of als er een time-out optreedt.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Start een asynchrone peekbewerking met een opgegeven time-out en die gebruikmaakt van een opgegeven cursor, een opgegeven actie voor korte weergave en een opgegeven statusobject. Het statusobject bevat gekoppelde informatie gedurende de levensduur van de bewerking. Deze overbelasting ontvangt een melding via een callback van de identiteit van de gebeurtenis-handler voor de bewerking. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij of als er een time-out optreedt.
BeginPeek()	Hiermee wordt een asynchrone peekbewerking gestart die geen time-out heeft. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij.
BeginPeek(TimeSpan)	Hiermee wordt een asynchrone peekbewerking gestart met een opgegeven time-out. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij of als er een time-out optreedt.

BeginPeek(TimeSpan, Object, AsyncCallback)

Start een asynchrone peek-bewerking met een opgegeven time-out en een opgegeven statusobject, dat gekoppelde informatie biedt gedurende de levensduur van de bewerking. Deze overbelasting ontvangt een melding via een callback van de identiteit van de gebeurtenis-handler voor de bewerking. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij of als er een time-out optreedt.

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

Parameters

timeout: TimeSpan

A TimeSpan die het tijdsinterval aangeeft waarop moet worden gewacht totdat een bericht beschikbaar is.

stateObject: Object

Een statusobject, opgegeven door de toepassing, dat informatie bevat die is gekoppeld aan de asynchrone bewerking.

callback: AsyncCallback

Hiermee AsyncCallback ontvangt u de melding van de voltooiing van de asynchrone bewerking.

Retouren

IAsyncResult

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

ArgumentException

De waarde die is opgegeven voor de parameter timeout is ongeldig.

MessageQueueException

Er is een fout opgetreden bij het openen van een Message Queuing-methode.

Voorbeelden

In het volgende codevoorbeeld wordt een asynchrone peek-bewerking gemaakt. In het codevoorbeeld wordt een bericht verzonden naar een lokale berichtenwachtrij en vervolgens wordt aangeroepenBeginPeek(TimeSpan, Object, AsyncCallback), waarbij het volgende wordt doorgegeven: een time-outwaarde van tien seconden; een uniek geheel getal dat dat bericht identificeert; en een nieuw exemplaar van AsyncCallback dat de gebeurtenis-handler identificeert. MyPeekCompleted Wanneer een PeekCompleted gebeurtenis wordt gegenereerd, bekijkt de gebeurtenis-handler het bericht en schrijft de berichttekst en de id van het gehele bericht naar het scherm.

#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));
    }
}

Opmerkingen

Wanneer u deze overbelasting gebruikt, wordt de callback die is opgegeven in de callbackparameter rechtstreeks aangeroepen wanneer een bericht beschikbaar is in de wachtrij of wanneer het opgegeven tijdsinterval is verlopen; de PeekCompleted gebeurtenis wordt niet gegenereerd. De andere overbelastingen zijn afhankelijk van BeginPeek dit onderdeel om de PeekCompleted gebeurtenis te verhogen.

PeekCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

De BeginPeek methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Omdat BeginPeek dit asynchroon is, kunt u deze aanroepen om de wachtrij te bekijken zonder de huidige thread van de uitvoering te blokkeren. Als u de wachtrij synchroon wilt bekijken, gebruikt u de Peek methode.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

BeginPeek retourneert een IAsyncResult die de asynchrone bewerking identificeert die door de methode is gestart. U kunt dit IAsyncResult gedurende de hele levensduur van de bewerking gebruiken, hoewel u deze over het algemeen niet gebruikt totdat EndPeek(IAsyncResult) deze wordt aangeroepen. Als u echter verschillende asynchrone bewerkingen start, kunt u de IAsyncResult waarden in een matrix plaatsen en opgeven of u wilt wachten tot alle bewerkingen of bewerkingen zijn voltooid. In dit geval gebruikt u de AsyncWaitHandle eigenschap van de IAsyncResult functie om de voltooide bewerking te identificeren.

Het statusobject koppelt statusgegevens aan de bewerking. Als u bijvoorbeeld meerdere keren aanroept BeginPeek om meerdere bewerkingen te starten, kunt u elke bewerking identificeren via een afzonderlijk statusobject dat u definieert.

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

Van toepassing op

BeginPeek(TimeSpan, Object)

Start een asynchrone peek-bewerking met een opgegeven time-out en een opgegeven statusobject, dat gekoppelde informatie biedt gedurende de levensduur van de bewerking. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij of als er een time-out optreedt.

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

Parameters

timeout: TimeSpan

A TimeSpan die het tijdsinterval aangeeft waarop moet worden gewacht totdat een bericht beschikbaar is.

stateObject: Object

Een statusobject, opgegeven door de toepassing, dat informatie bevat die is gekoppeld aan de asynchrone bewerking.

Retouren

IAsyncResult

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

ArgumentException

De waarde die is opgegeven voor de parameter timeout is ongeldig.

MessageQueueException

Er is een fout opgetreden bij het openen van een Message Queuing-methode.

Voorbeelden

In het volgende codevoorbeeld wordt een asynchrone peek-bewerking gemaakt met behulp van het wachtrijpad .\myQueue. Er wordt een gebeurtenis-handler MyPeekCompletedgemaakt en gekoppeld aan de gemachtigde van de PeekCompleted gebeurtenis-handler. BeginPeek wordt aangeroepen, met een time-out van één minuut. Elke aanroep naar BeginPeek een uniek gekoppeld geheel getal dat die specifieke bewerking identificeert. Wanneer een PeekCompleted gebeurtenis wordt gegenereerd of de time-out is verlopen, wordt het bericht, indien aanwezig, opgehaald en de hoofdtekst en de bewerkingsspecifieke geheel getal-id naar het scherm geschreven. Vervolgens BeginPeek wordt opnieuw aangeroepen om een nieuwe asynchrone peek-bewerking te starten met dezelfde time-out en het bijbehorende gehele getal van de zojuist voltooide bewerking.

#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

Opmerkingen

Bij asynchrone verwerking gebruikt BeginPeek u om de PeekCompleted gebeurtenis te genereren wanneer een bericht beschikbaar komt in de wachtrij of wanneer het opgegeven tijdsinterval is verlopen.

PeekCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

Gebruik deze overbelasting om informatie te koppelen aan de bewerking die gedurende de levensduur van de bewerking behouden blijft. De gebeurtenis-handler heeft toegang tot deze informatie door naar de AsyncState eigenschap te kijken van de IAsyncResult eigenschap die is gekoppeld aan de bewerking.

Als u dit wilt gebruiken BeginPeek, maakt u een gebeurtenis-handler die de resultaten van de asynchrone bewerking verwerkt en koppelt u deze aan de gemachtigde van de gebeurtenis. BeginPeek initieert een asynchrone peek-bewerking; de MessageQueue melding wordt ontvangen door middel van het genereren van de PeekCompleted gebeurtenis wanneer een bericht in de wachtrij binnenkomt. De MessageQueue kan het bericht vervolgens openen door te bellen EndPeek(IAsyncResult) of door het resultaat op te halen met behulp van de PeekCompletedEventArgs.

De BeginPeek methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

Deze overbelasting geeft een time-out en een statusobject op. Als het interval dat door de timeout parameter is opgegeven, verloopt, wordt de PeekCompleted gebeurtenis gegenereerd door dit onderdeel. Omdat er geen bericht bestaat, genereert een volgende aanroep een EndPeek(IAsyncResult) uitzondering.

U kunt het statusobject ook gebruiken om informatie door te geven over procesthreads. Als een thread wordt gestart, maar de callback zich op een andere thread in een asynchroon scenario bevindt, wordt het statusobject marshaled en wordt het doorgegeven samen met informatie van de gebeurtenis.

Als CanRead dat het geval is false, wordt de voltooiingsgebeurtenis gegenereerd, maar er wordt een uitzondering gegenereerd bij het aanroepen EndPeek(IAsyncResult).

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

Van toepassing op

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

Start een asynchrone peekbewerking met een opgegeven time-out en die gebruikmaakt van een opgegeven cursor, een opgegeven actie voor korte weergave en een opgegeven statusobject. Het statusobject bevat gekoppelde informatie gedurende de levensduur van de bewerking. Deze overbelasting ontvangt een melding via een callback van de identiteit van de gebeurtenis-handler voor de bewerking. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij of als er een time-out optreedt.

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

Parameters

timeout: TimeSpan

A TimeSpan die het tijdsinterval aangeeft waarop moet worden gewacht totdat een bericht beschikbaar is.

cursor: Cursor

Een Cursor die een specifieke positie in de berichtenwachtrij onderhoudt.

action: PeekAction

Een van de PeekAction waarden. Hiermee wordt aangegeven of u het huidige bericht in de wachtrij of het volgende bericht wilt bekijken.

state: Object

Een statusobject, opgegeven door de toepassing, dat informatie bevat die is gekoppeld aan de asynchrone bewerking.

callback: AsyncCallback

De AsyncCallback melding dat de asynchrone bewerking is voltooid.

Retouren

IAsyncResult

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

ArgumentOutOfRangeException

Een andere waarde dan PeekAction.Current of PeekAction.Next is opgegeven voor de action parameter.

ArgumentNullException

De cursor parameter is null.

ArgumentException

De waarde die is opgegeven voor de parameter timeout is ongeldig.

MessageQueueException

Er is een fout opgetreden bij het openen van een Message Queuing-methode.

Opmerkingen

Wanneer u deze overbelasting gebruikt, wordt de callback die is opgegeven in de callback-parameter rechtstreeks aangeroepen wanneer een bericht beschikbaar is in de wachtrij of wanneer het opgegeven tijdsinterval is verlopen. De PeekCompleted gebeurtenis wordt niet gegenereerd. De andere overbelastingen zijn afhankelijk van BeginPeek dit onderdeel om de PeekCompleted gebeurtenis te verhogen.

PeekCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

De BeginPeek methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

Van toepassing op

BeginPeek()

Hiermee wordt een asynchrone peekbewerking gestart die geen time-out heeft. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij.

public:
 IAsyncResult ^ BeginPeek();

public IAsyncResult BeginPeek();

member this.BeginPeek : unit -> IAsyncResult

Public Function BeginPeek () As IAsyncResult

Retouren

IAsyncResult

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

MessageQueueException

Er is een fout opgetreden bij het openen van een Message Queuing-methode.

Voorbeelden

In het volgende codevoorbeeld wordt een gebeurtenishandler met de naam gemaakt MyPeekCompleted, gekoppeld aan de gemachtigde van de PeekCompleted gebeurtenis-handler en wordt aangeroepen BeginPeek om een asynchrone peek-bewerking te starten in de wachtrij die zich in het pad '.\myQueue' bevindt. Wanneer een PeekCompleted gebeurtenis wordt gegenereerd, wordt het bericht in het voorbeeld weergegeven en wordt de hoofdtekst naar het scherm geschreven. Het voorbeeld roept BeginPeek vervolgens opnieuw aan om een nieuwe asynchrone peek-bewerking te starten.

#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

Opmerkingen

Bij asynchrone verwerking gebruikt BeginPeek u om de PeekCompleted gebeurtenis te genereren wanneer een bericht beschikbaar wordt in de wachtrij.

PeekCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

De BeginPeek methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

De IAsyncResult retourneert BeginPeek de asynchrone bewerking die door de methode is gestart. U kunt dit IAsyncResult gedurende de hele levensduur van de bewerking gebruiken, hoewel u deze over het algemeen niet gebruikt totdat EndPeek(IAsyncResult) deze wordt aangeroepen. Als u echter verschillende asynchrone bewerkingen start, kunt u de IAsyncResult waarden in een matrix plaatsen en opgeven of u wilt wachten tot alle bewerkingen of bewerkingen zijn voltooid. In dit geval gebruikt u de AsyncWaitHandle eigenschap van de IAsyncResult functie om de voltooide bewerking te identificeren.

Als CanRead dat het geval is false, wordt de voltooiingsgebeurtenis gegenereerd, maar er wordt een uitzondering gegenereerd bij het aanroepen EndPeek(IAsyncResult).

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

Van toepassing op

BeginPeek(TimeSpan)

Hiermee wordt een asynchrone peekbewerking gestart met een opgegeven time-out. De bewerking is pas voltooid als er een bericht beschikbaar is in de wachtrij of als er een time-out optreedt.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout);

public IAsyncResult BeginPeek(TimeSpan timeout);

member this.BeginPeek : TimeSpan -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan) As IAsyncResult

Parameters

timeout: TimeSpan

A TimeSpan die het tijdsinterval aangeeft waarop moet worden gewacht totdat een bericht beschikbaar is.

Retouren

IAsyncResult

Hiermee IAsyncResult wordt de geplaatste asynchrone aanvraag geïdentificeerd.

Uitzonderingen

ArgumentException

De waarde die is opgegeven voor de parameter timeout is ongeldig.

MessageQueueException

Er is een fout opgetreden bij het openen van een Message Queuing-methode.

Voorbeelden

In het volgende codevoorbeeld wordt een asynchrone peek-bewerking gemaakt met behulp van het wachtrijpad .\myQueue. Er wordt een gebeurtenis-handler MyPeekCompletedgemaakt en gekoppeld aan de gemachtigde van de PeekCompleted gebeurtenis-handler. BeginPeek wordt aangeroepen met een time-out van één minuut om de asynchrone weergavebewerking te starten. Wanneer een PeekCompleted gebeurtenis wordt gegenereerd of de time-out verloopt, wordt het bericht opgehaald als er een bestaat en wordt de hoofdtekst naar het scherm geschreven. Vervolgens BeginPeek wordt opnieuw aangeroepen om een nieuwe asynchrone peek-bewerking te starten met dezelfde time-out.

#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

Opmerkingen

Bij asynchrone verwerking gebruikt BeginPeek u om de PeekCompleted gebeurtenis te genereren wanneer een bericht beschikbaar komt in de wachtrij of wanneer het opgegeven tijdsinterval is verlopen.

PeekCompleted wordt ook gegenereerd als er al een bericht in de wachtrij bestaat.

De BeginPeek methode retourneert onmiddellijk, maar de asynchrone bewerking wordt pas voltooid als de gebeurtenis-handler wordt aangeroepen.

Zodra een asynchrone bewerking is voltooid, kunt u in de gebeurtenis-handler bellen of BeginReceive opnieuw bellen BeginPeek om meldingen te blijven ontvangen.

Deze overbelasting geeft een time-out op. Als het interval dat door de timeout parameter is opgegeven, verloopt, wordt de PeekCompleted gebeurtenis gegenereerd door dit onderdeel. Omdat er geen bericht bestaat, genereert een volgende aanroep een EndPeek(IAsyncResult) uitzondering.

Als CanRead dat het geval is false, wordt de voltooiingsgebeurtenis gegenereerd, maar er wordt een uitzondering gegenereerd bij het aanroepen EndPeek(IAsyncResult).

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

Van toepassing op

Veiligheid thread

De methode is niet thread safe.

Feedback

Is deze pagina nuttig?