MessageQueue.BeginPeek Metod

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

Parametrar

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Exempel

I följande kodexempel skapas en asynkron granskningsåtgärd. Kodexemplet skickar ett meddelande till en lokal meddelandekö och anropar BeginPeek(TimeSpan, Object, AsyncCallback), skickar in: ett timeout-värde på tio sekunder, ett unikt heltal som identifierar det specifika meddelandet och en ny instans av AsyncCallback som identifierar händelsehanteraren. MyPeekCompleted När en PeekCompleted händelse utlöses tittar händelsehanteraren på meddelandet och skriver meddelandetexten och heltalsmeddelandeidentifieraren till skärmen.

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

Kommentarer

När du använder den här överbelastningen anropas återanropet som anges i motringningsparametern direkt när ett meddelande blir tillgängligt i kön eller när det angivna tidsintervallet har upphört att gälla. händelsen PeekCompleted har inte aktiverats. De andra överlagringarna av BeginPeek förlitar sig på den här komponenten PeekCompleted för att generera händelsen.

PeekCompleted utlöses också om det redan finns ett meddelande i kön.

Metoden BeginPeek returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginPeek är asynkron kan du anropa den för att granska kön utan att blockera den aktuella körningstråden. Om du vill granska kön synkront använder du Peek metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

BeginPeek returnerar en IAsyncResult som identifierar den asynkrona åtgärd som metoden startade. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndPeek(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder AsyncWaitHandle du egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Tillståndsobjektet associerar tillståndsinformation med åtgärden. Om du till exempel anropar BeginPeek flera gånger för att initiera flera åtgärder kan du identifiera varje åtgärd via ett separat tillståndsobjekt som du definierar.

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()
• AsyncCallback
• TimeSpan

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

Parametrar

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Exempel

I följande kodexempel skapas en asynkron granskningsåtgärd med hjälp av kösökvägen ".\myQueue". Den skapar en händelsehanterare, MyPeekCompleted, och kopplar den till händelsehanterardelegaten PeekCompleted . BeginPeek anropas med en timeout på en minut. Varje anrop till BeginPeek har ett unikt associerat heltal som identifierar den specifika åtgärden. När en PeekCompleted händelse utlöses eller tidsgränsen upphörde att gälla hämtas meddelandet, om det finns en sådan, och dess brödtext och det åtgärdsspecifika heltalsidentifieraren skrivs till skärmen. Anropas sedan BeginPeek igen för att initiera en ny asynkron granskningsåtgärd med samma timeout och det associerade heltalet för den just slutförda åtgärden.

#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

Kommentarer

Vid asynkron bearbetning använder BeginPeek du för att skapa PeekCompleted händelsen när ett meddelande blir tillgängligt i kön eller när det angivna tidsintervallet har upphört att gälla.

PeekCompleted utlöses också om det redan finns ett meddelande i kön.

Använd den här överlagringen för att associera information med den åtgärd som ska bevaras under hela åtgärdens livslängd. Händelsehanteraren kan komma åt den här informationen genom att titta på AsyncState egenskapen för den IAsyncResult som är associerad med åtgärden.

Om du vill använda BeginPeekskapar du en händelsehanterare som bearbetar resultatet av den asynkrona åtgärden och associerar den med händelsedelegaten. BeginPeek initierar en asynkron granskningsåtgärd. MessageQueue meddelas, genom att händelsen höjs PeekCompleted , när ett meddelande tas emot i kön. MessageQueue Kan sedan komma åt meddelandet genom att anropa EndPeek(IAsyncResult) eller genom att hämta resultatet med hjälp av PeekCompletedEventArgs.

Metoden BeginPeek returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginPeek är asynkron kan du anropa den för att granska kön utan att blockera den aktuella körningstråden. Om du vill granska kön synkront använder du Peek metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

BeginPeek returnerar en IAsyncResult som identifierar den asynkrona åtgärd som metoden startade. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndPeek(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder AsyncWaitHandle du egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Den här överlagringen anger en timeout och ett tillståndsobjekt. Om intervallet som anges av parametern timeout upphör att gälla genererar den här komponenten PeekCompleted händelsen. Eftersom det inte finns något meddelande utlöser ett efterföljande anrop till EndPeek(IAsyncResult) ett undantag.

Tillståndsobjektet associerar tillståndsinformation med åtgärden. Om du till exempel anropar BeginPeek flera gånger för att initiera flera åtgärder kan du identifiera varje åtgärd via ett separat tillståndsobjekt som du definierar. En bild av det här scenariot finns i avsnittet Exempel.

Du kan också använda tillståndsobjektet för att skicka information mellan processtrådar. Om en tråd startas men återanropet finns på en annan tråd i ett asynkront scenario, konverteras tillståndsobjektet och skickas tillbaka tillsammans med information från händelsen.

Om CanRead är falseutlöses slutförandehändelsen, men ett undantag utlöses när du anropar EndPeek(IAsyncResult).

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()
• TimeSpan

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

Parametrar

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Kommentarer

När du använder den här överlagringen anropas återanropet som anges i parametern för återanrop direkt när ett meddelande blir tillgängligt i kön eller när det angivna tidsintervallet har upphört att gälla. Händelsen PeekCompleted aktiveras inte. De andra överlagringarna av BeginPeek förlitar sig på den här komponenten PeekCompleted för att generera händelsen.

PeekCompleted utlöses också om det redan finns ett meddelande i kön.

Metoden BeginPeek returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginPeek är asynkron kan du anropa den för att granska kön utan att blockera den aktuella körningstråden. Om du vill granska kön synkront använder du Peek metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

BeginPeek returnerar en IAsyncResult som identifierar den asynkrona åtgärd som startades av metoden. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndPeek(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder du AsyncWaitHandle egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Tillståndsobjektet associerar tillståndsinformation med åtgärden. Om du till exempel anropar BeginPeek flera gånger för att initiera flera åtgärder kan du identifiera varje åtgärd via ett separat tillståndsobjekt som du definierar.

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()
• AsyncCallback
• TimeSpan

public:
 IAsyncResult ^ BeginPeek();

public IAsyncResult BeginPeek();

member this.BeginPeek : unit -> IAsyncResult

Public Function BeginPeek () As IAsyncResult

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Exempel

I följande kodexempel skapas en händelsehanterare med namnet MyPeekCompleted, kopplar den till händelsehanterardelegaten PeekCompleted och anropar BeginPeek för att initiera en asynkron granskningsåtgärd i kön som finns på sökvägen ".\myQueue". När en PeekCompleted händelse utlöses tittar exemplet på meddelandet och skriver dess brödtext till skärmen. Exemplet anropar BeginPeek sedan igen för att initiera en ny asynkron granskningsåtgärd.

#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

Kommentarer

Vid asynkron bearbetning använder BeginPeek du för att skapa PeekCompleted händelsen när ett meddelande blir tillgängligt i kön.

PeekCompleted utlöses också om det redan finns ett meddelande i kön.

Om du vill använda BeginPeekskapar du en händelsehanterare som bearbetar resultatet av den asynkrona åtgärden och associerar den med händelsedelegaten. BeginPeek initierar en asynkron granskningsåtgärd. MessageQueue meddelas, genom att händelsen höjs PeekCompleted , när ett meddelande tas emot i kön. MessageQueue Kan sedan komma åt meddelandet genom att anropa EndPeek(IAsyncResult) eller genom att hämta resultatet med hjälp av PeekCompletedEventArgs.

Metoden BeginPeek returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginPeek är asynkron kan du anropa den för att granska kön utan att blockera den aktuella körningstråden. Om du vill granska kön synkront använder du Peek metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

IAsyncResult Som BeginPeek returnerar identifierar den asynkrona åtgärd som metoden startade. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndPeek(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder AsyncWaitHandle du egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Om CanRead är falseutlöses slutförandehändelsen, men ett undantag utlöses när du anropar EndPeek(IAsyncResult).

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout);

public IAsyncResult BeginPeek(TimeSpan timeout);

member this.BeginPeek : TimeSpan -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan) As IAsyncResult

Parametrar

Returer

Som IAsyncResult identifierar den publicerade asynkrona begäran.

Undantag

Exempel

I följande kodexempel skapas en asynkron granskningsåtgärd med hjälp av kösökvägen ".\myQueue". Den skapar en händelsehanterare, MyPeekCompleted, och kopplar den till händelsehanterardelegaten PeekCompleted . BeginPeek anropas med en timeout på en minut för att initiera den asynkrona granskningsåtgärden. När en PeekCompleted händelse utlöses eller tidsgränsen upphör att gälla hämtas meddelandet om en sådan finns och dess brödtext skrivs till skärmen. Anropas sedan BeginPeek igen för att initiera en ny asynkron granskningsåtgärd med samma timeout.

#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

Kommentarer

Vid asynkron bearbetning använder BeginPeek du för att skapa PeekCompleted händelsen när ett meddelande blir tillgängligt i kön eller när det angivna tidsintervallet har upphört att gälla.

PeekCompleted utlöses också om det redan finns ett meddelande i kön.

Om du vill använda BeginPeekskapar du en händelsehanterare som bearbetar resultatet av den asynkrona åtgärden och associerar den med händelsedelegaten. BeginPeek initierar en asynkron granskningsåtgärd. MessageQueue meddelas, genom att händelsen höjs PeekCompleted , när ett meddelande tas emot i kön. MessageQueue Kan sedan komma åt meddelandet genom att anropa EndPeek(IAsyncResult) eller genom att hämta resultatet med hjälp av PeekCompletedEventArgs.

Metoden BeginPeek returnerar omedelbart, men den asynkrona åtgärden slutförs inte förrän händelsehanteraren anropas.

Eftersom BeginPeek är asynkron kan du anropa den för att granska kön utan att blockera den aktuella körningstråden. Om du vill granska kön synkront använder du Peek metoden .

När en asynkron åtgärd har slutförts kan du anropa BeginPeek eller BeginReceive igen i händelsehanteraren för att fortsätta ta emot meddelanden.

IAsyncResult Som BeginPeek returnerar identifierar den asynkrona åtgärd som metoden startade. Du kan använda detta IAsyncResult under hela åtgärdens livslängd, även om du vanligtvis inte använder det förrän det anropas EndPeek(IAsyncResult) . Men om du startar flera asynkrona åtgärder kan du placera deras IAsyncResult värden i en matris och ange om du vill vänta tills alla åtgärder eller åtgärder har slutförts. I det här fallet använder AsyncWaitHandle du egenskapen IAsyncResult för för att identifiera den slutförda åtgärden.

Den här överlagringen anger en tidsgräns. Om intervallet som anges av parametern timeout upphör att gälla genererar den här komponenten PeekCompleted händelsen. Eftersom det inte finns något meddelande utlöser ett efterföljande anrop till EndPeek(IAsyncResult) ett undantag.

Om CanRead är falseutlöses slutförandehändelsen, men ett undantag utlöses när du anropar EndPeek(IAsyncResult).

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• PeekCompleted
• BeginReceive()
• Peek()
• Receive()
• TimeSpan