MessageQueue.BeginPeek Metódus

Definíció

Névtér:
System.Messaging
Szerelvény:
System.Messaging.dll

Aszinkron betekintő műveletet kezdeményez úgy, hogy közli a Message Queuing szolgáltatással, hogy kezdjen betekinteni egy üzenetbe, és ha elkészült, értesítse az eseménykezelőt.

Túlterhelések

Name Description
BeginPeek(TimeSpan, Object, AsyncCallback)

Elindít egy aszinkron betekintő műveletet, amely egy megadott időtúllépési és egy megadott állapotobjektummal rendelkezik, amely a művelet teljes élettartama során kapcsolódó információkat biztosít. Ez a túlterhelés egy visszahíváson keresztül értesítést kap a művelet eseménykezelőjének identitásáról. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.
BeginPeek(TimeSpan, Object)

Elindít egy aszinkron betekintő műveletet, amely egy megadott időtúllépési és egy megadott állapotobjektummal rendelkezik, amely a művelet teljes élettartama során kapcsolódó információkat biztosít. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Elindít egy aszinkron betekintő műveletet, amely egy megadott időtúllépéssel rendelkezik, és egy adott kurzort, egy adott betekintő műveletet és egy megadott állapotobjektumot használ. Az állapotobjektum a művelet teljes élettartama során biztosít kapcsolódó információkat. Ez a túlterhelés egy visszahíváson keresztül értesítést kap a művelet eseménykezelőjének identitásáról. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.
BeginPeek()

Olyan aszinkron betekintő műveletet kezdeményez, amelynek nincs időtúllépése. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban.
BeginPeek(TimeSpan)

Elindít egy aszinkron betekintő műveletet, amely egy megadott időtúllépéssel rendelkezik. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

BeginPeek(TimeSpan, Object, AsyncCallback)

Elindít egy aszinkron betekintő műveletet, amely egy megadott időtúllépési és egy megadott állapotobjektummal rendelkezik, amely a művelet teljes élettartama során kapcsolódó információkat biztosít. Ez a túlterhelés egy visszahíváson keresztül értesítést kap a művelet eseménykezelőjének identitásáról. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

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

Paraméterek

timeout
TimeSpan

Ez TimeSpan azt az időtartamot jelzi, amíg egy üzenet elérhetővé válik.

stateObject
Object

Az alkalmazás által megadott állapotobjektum, amely az aszinkron művelethez társított információkat tartalmazza.

callback
AsyncCallback

A AsyncCallback rendszer értesítést kap az aszinkron művelet befejezéséről.

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

ArgumentException

A timeout paraméterhez megadott érték érvénytelen.

MessageQueueException

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

Példák

Az alábbi példakód egy aszinkron betekintő műveletet hoz létre. A példakód egy üzenetet küld egy helyi üzenetsorba, majd meghívja a következőtBeginPeek(TimeSpan, Object, AsyncCallback): egy tíz másodperces időtúllépési érték, egy egyedi egész szám, amely azonosítja az adott üzenetet, és egy új példányAsyncCallback, amely azonosítja az eseménykezelőt. MyPeekCompleted PeekCompleted Esemény létrehozásakor az eseménykezelő betekint az üzenetbe, és a képernyőre írja az üzenet törzsét és az egész szám üzenetazonosítóját.

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

Megjegyzések

Ha ezt a túlterhelést használja, a visszahívási paraméterben megadott visszahívás közvetlenül akkor lesz meghívva, ha egy üzenet elérhetővé válik az üzenetsorban, vagy ha a megadott időtartam lejárt; az PeekCompleted esemény nincs előállítva. A többi túlterhelés az BeginPeek összetevőre támaszkodva növeli az eseményt PeekCompleted .

PeekCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

A BeginPeek metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Mivel BeginPeek aszinkron, hívhatja úgy, hogy betekintsen az üzenetsorba anélkül, hogy blokkolta volna az aktuális végrehajtási szálat. Az üzenetsor szinkronizálásához használja a metódust Peek .

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

BeginPeek A IAsyncResult metódus által elindított aszinkron műveletet azonosító aszinkron műveletet adja vissza. Ezt IAsyncResult a művelet teljes élettartama alatt használhatja, bár általában csak akkor használja, ha EndPeek(IAsyncResult) meghívják. Ha azonban több aszinkron műveletet indít el, az értékeket IAsyncResult elhelyezheti egy tömbben, és megadhatja, hogy várnia kell-e az összes művelet vagy bármely művelet befejezésére. Ebben az esetben a befejezett művelet azonosításához használja AsyncWaitHandle a IAsyncResult tulajdonságot.

Az állapotobjektum az állapotinformációkat társítja a művelethez. Ha például többször is meghív BeginPeek több műveletet, az egyes műveleteket egy ön által meghatározott külön állapotobjektumon keresztül azonosíthatja.

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

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

Lásd még

A következőre érvényes:

BeginPeek(TimeSpan, Object)

Elindít egy aszinkron betekintő műveletet, amely egy megadott időtúllépési és egy megadott állapotobjektummal rendelkezik, amely a művelet teljes élettartama során kapcsolódó információkat biztosít. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

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

Paraméterek

timeout
TimeSpan

Ez TimeSpan azt az időtartamot jelzi, amíg egy üzenet elérhetővé válik.

stateObject
Object

Az alkalmazás által megadott állapotobjektum, amely az aszinkron művelethez társított információkat tartalmazza.

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

ArgumentException

A timeout paraméterhez megadott érték érvénytelen.

MessageQueueException

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

Példák

Az alábbi példakód egy aszinkron betekintő műveletet hoz létre a ".\myQueue" üzenetsor elérési útjának használatával. Létrehoz egy eseménykezelőt, MyPeekCompletedés csatolja az PeekCompleted eseménykezelő delegálthoz. BeginPeek egy percből álló időtúllépéssel hívjuk meg. Minden híváshoz BeginPeek egyedi társított egész szám tartozik, amely azonosítja az adott műveletet. Amikor egy PeekCompleted eseményt emelnek ki, vagy lejárt az időkorlát, a rendszer lekéri az üzenetet, ha van ilyen, és a rendszer a szövegtörzset és a műveletspecifikus egész számazonosítót írja a képernyőre. Ezután BeginPeek a rendszer ismét meghívja egy új aszinkron betekintő műveletet ugyanazzal az időtúllépéssel és az imént befejezett művelet társított egész számával.

#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

Megjegyzések

Az aszinkron feldolgozás során az eseményt akkor emeli BeginPeek ki PeekCompleted , ha egy üzenet elérhetővé válik az üzenetsorban, vagy ha a megadott időintervallum lejárt.

PeekCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

Ezzel a túlterheléssel olyan információkat társíthat a művelethez, amelyek a művelet teljes élettartama alatt megmaradnak. Az eseménykezelő a művelethez társított tulajdonsággal férhet hozzá ezekhez az AsyncState információkhozIAsyncResult.

A használathoz BeginPeekhozzon létre egy eseménykezelőt, amely feldolgozza az aszinkron művelet eredményeit, és társítja azt az eseménymegbízotthoz. BeginPeek aszinkron betekintő műveletet kezdeményez; a MessageQueue rendszer az esemény felemelésével PeekCompleted értesítést kap, amikor egy üzenet érkezik az üzenetsorba. Ezután MessageQueue az üzenethez hívással EndPeek(IAsyncResult) vagy az eredmény beolvasásával érheti el az üzenetet a PeekCompletedEventArgs.

A BeginPeek metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Mivel BeginPeek aszinkron, hívhatja úgy, hogy betekintsen az üzenetsorba anélkül, hogy blokkolta volna az aktuális végrehajtási szálat. Az üzenetsor szinkronizálásához használja a metódust Peek .

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

BeginPeek A IAsyncResult metódus által elindított aszinkron műveletet azonosító aszinkron műveletet adja vissza. Ezt IAsyncResult a művelet teljes élettartama alatt használhatja, bár általában csak akkor használja, ha EndPeek(IAsyncResult) meghívják. Ha azonban több aszinkron műveletet indít el, az értékeket IAsyncResult elhelyezheti egy tömbben, és megadhatja, hogy várnia kell-e az összes művelet vagy bármely művelet befejezésére. Ebben az esetben a befejezett művelet azonosításához használja AsyncWaitHandle a IAsyncResult tulajdonságot.

Ez a túlterhelés időtúllépést és állapotobjektumot határoz meg. Ha a timeout paraméter által megadott időköz lejár, ez az összetevő aktiválja az eseményt PeekCompleted . Mivel nincs üzenet, egy későbbi hívás kivételt fog eredményezni EndPeek(IAsyncResult) .

Az állapotobjektum az állapotinformációkat társítja a művelethez. Ha például többször is meghív BeginPeek több műveletet, az egyes műveleteket egy ön által meghatározott külön állapotobjektumon keresztül azonosíthatja. A forgatókönyv illusztrációját a Példa szakaszban találja.

Az állapotobjektummal adatokat is továbbíthat a folyamatszálak között. Ha egy szál el van indítva, de a visszahívás egy másik szálon van aszinkron forgatókönyvben, az állapotobjektumot a rendszer marsallja, és visszaadja az esemény információival együtt.

Ha CanRead igen false, a befejezési esemény létrejön, de a hívás EndPeek(IAsyncResult)során kivétel lép fel.

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

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

Lásd még

A következőre érvényes:

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

Elindít egy aszinkron betekintő műveletet, amely egy megadott időtúllépéssel rendelkezik, és egy adott kurzort, egy adott betekintő műveletet és egy megadott állapotobjektumot használ. Az állapotobjektum a művelet teljes élettartama során biztosít kapcsolódó információkat. Ez a túlterhelés egy visszahíváson keresztül értesítést kap a művelet eseménykezelőjének identitásáról. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

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

Paraméterek

timeout
TimeSpan

Ez TimeSpan azt az időtartamot jelzi, amíg egy üzenet elérhetővé válik.

cursor
Cursor

Egy Cursor adott pozíciót tart fenn az üzenetsorban.

action
PeekAction

Az egyik PeekAction érték. Azt jelzi, hogy az üzenetsor aktuális üzenetére vagy a következő üzenetre szeretne-e betekinteni.

state
Object

Az alkalmazás által megadott állapotobjektum, amely az aszinkron művelethez társított információkat tartalmazza.

callback
AsyncCallback

Az AsyncCallback aszinkron művelet befejezéséről szóló értesítést kapó.

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

ArgumentOutOfRangeException

A paraméteren PeekAction.Current kívüli PeekAction.Next vagy action megadott érték.

ArgumentNullException

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

ArgumentException

A timeout paraméterhez megadott érték érvénytelen.

MessageQueueException

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

Megjegyzések

Ha ezt a túlterhelést használja, a visszahívási paraméterben megadott visszahívást a rendszer közvetlenül meghívja, amikor egy üzenet elérhetővé válik az üzenetsorban, vagy ha a megadott időtartam lejárt. Az PeekCompleted esemény nincs előállítva. A többi túlterhelés az BeginPeek összetevőre támaszkodva növeli az eseményt PeekCompleted .

PeekCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

A BeginPeek metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Mivel BeginPeek aszinkron, hívhatja úgy, hogy betekintsen az üzenetsorba anélkül, hogy blokkolta volna az aktuális végrehajtási szálat. Az üzenetsor szinkronizálásához használja a metódust Peek .

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

BeginPeek A IAsyncResult metódus által elindított aszinkron műveletet azonosító aszinkron műveletet ad vissza. Ezt IAsyncResult a művelet teljes élettartama alatt használhatja, bár általában csak akkor használja, ha EndPeek(IAsyncResult) meghívják. Ha azonban több aszinkron műveletet indít el, az értékeket IAsyncResult elhelyezheti egy tömbben, és megadhatja, hogy várnia kell-e az összes művelet vagy bármely művelet befejezésére. Ebben az esetben használja a AsyncWaitHandle tulajdonságot a IAsyncResult befejezett művelet azonosításához.

Az állapotobjektum az állapotinformációkat társítja a művelethez. Ha például többször is meghív BeginPeek több műveletet, az egyes műveleteket egy ön által meghatározott külön állapotobjektumon keresztül azonosíthatja.

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

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

Lásd még

A következőre érvényes:

BeginPeek()

Olyan aszinkron betekintő műveletet kezdeményez, amelynek nincs időtúllépése. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban.

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

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

MessageQueueException

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

Példák

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

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

using namespace System;
using namespace System::Messaging;

// This example performs asynchronous peek operation
// processing.
//*************************************************
ref class MyNewQueue
{
public:

   // Provides an event handler for the PeekCompleted
   // event.
   static void MyPeekCompleted( Object^ source, PeekCompletedEventArgs^ asyncResult )
   {
      // Connect to the queue.
      MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

      // End the asynchronous peek operation.
      Message^ m = mq->EndPeek( asyncResult->AsyncResult );

      // Display message information on the screen.
      Console::WriteLine( "Message: {0}", static_cast<String^>(m->Body) );

      // Restart the asynchronous peek operation.
      mq->BeginPeek();
      return;
   }
};

// Provides an entry point into the application.
//         
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the PeekCompleted event.
   myQueue->PeekCompleted += gcnew PeekCompletedEventHandler( MyNewQueue::MyPeekCompleted );

   // Begin the asynchronous peek operation.
   myQueue->BeginPeek();

   // Do other work on the current thread.
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {
        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous peek operation
        // processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the PeekCompleted event.
            myQueue.PeekCompleted += new
                PeekCompletedEventHandler(MyPeekCompleted);

            // Begin the asynchronous peek operation.
            myQueue.BeginPeek();

            // Do other work on the current thread.

            return;
        }

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

        private static void MyPeekCompleted(Object source,
            PeekCompletedEventArgs asyncResult)
        {
            // Connect to the queue.
            MessageQueue mq = (MessageQueue)source;

            // End the asynchronous peek operation.
            Message m = mq.EndPeek(asyncResult.AsyncResult);

            // Display message information on the screen.
            Console.WriteLine("Message: " + (string)m.Body);

            // Restart the asynchronous peek operation.
            mq.BeginPeek();

            return;
        }
    }
}

Imports System.Messaging





' Provides a container class for the example.
Public Class MyNewQueue



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous peek operation
        ' processing.


        Public Shared Sub Main()
            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the PeekCompleted event.
            AddHandler myQueue.PeekCompleted, AddressOf _
                MyPeekCompleted

            ' Begin the asynchronous peek operation.
            myQueue.BeginPeek()

            ' Do other work on the current thread.
            Return
        End Sub


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

        Private Shared Sub MyPeekCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As PeekCompletedEventArgs)

            ' Connect to the queue.
            Dim mq As MessageQueue = CType([source], MessageQueue)

            ' End the asynchronous peek operation.
            Dim m As Message = mq.EndPeek(asyncResult.AsyncResult)

            ' Display message information on the screen.
            Console.WriteLine(("Message: " + CStr(m.Body)))

            ' Restart the asynchronous peek operation.
            mq.BeginPeek()

            Return

        End Sub

End Class

Megjegyzések

Az aszinkron feldolgozás során az eseményt akkor emeli BeginPeek ki PeekCompleted , amikor egy üzenet elérhetővé válik az üzenetsorban.

PeekCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

A használathoz BeginPeekhozzon létre egy eseménykezelőt, amely feldolgozza az aszinkron művelet eredményeit, és társítja azt az eseménymegbízotthoz. BeginPeek aszinkron betekintő műveletet kezdeményez; a MessageQueue rendszer az esemény felemelésével PeekCompleted értesítést kap, amikor egy üzenet érkezik az üzenetsorba. Ezután MessageQueue az üzenethez hívással EndPeek(IAsyncResult) vagy az eredmény beolvasásával érheti el az üzenetet a PeekCompletedEventArgs.

A BeginPeek metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Mivel BeginPeek aszinkron, hívhatja úgy, hogy betekintsen az üzenetsorba anélkül, hogy blokkolta volna az aktuális végrehajtási szálat. Az üzenetsor szinkronizálásához használja a metódust Peek .

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

A IAsyncResult visszaadott BeginPeek érték azonosítja a metódus által elindított aszinkron műveletet. Ezt IAsyncResult a művelet teljes élettartama alatt használhatja, bár általában csak akkor használja, ha EndPeek(IAsyncResult) meghívják. Ha azonban több aszinkron műveletet indít el, az értékeket IAsyncResult elhelyezheti egy tömbben, és megadhatja, hogy várnia kell-e az összes művelet vagy bármely művelet befejezésére. Ebben az esetben a befejezett művelet azonosításához használja AsyncWaitHandle a IAsyncResult tulajdonságot.

Ha CanRead igen false, a befejezési esemény létrejön, de a hívás EndPeek(IAsyncResult)során kivétel lép fel.

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

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

Lásd még

A következőre érvényes:

BeginPeek(TimeSpan)

Elindít egy aszinkron betekintő műveletet, amely egy megadott időtúllépéssel rendelkezik. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

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

Paraméterek

timeout
TimeSpan

Ez TimeSpan azt az időtartamot jelzi, amíg egy üzenet elérhetővé válik.

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

ArgumentException

A timeout paraméterhez megadott érték érvénytelen.

MessageQueueException

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

Példák

Az alábbi példakód egy aszinkron betekintő műveletet hoz létre a ".\myQueue" üzenetsor elérési útjának használatával. Létrehoz egy eseménykezelőt, MyPeekCompletedés csatolja az PeekCompleted eseménykezelő delegálthoz. BeginPeek a rendszer az aszinkron betekintő művelet elindításához egy perc időtúllépéssel hívja meg. Amikor egy PeekCompleted esemény előjön, vagy az időtúllépés lejár, a rendszer lekéri az üzenetet, ha van ilyen, és a törzse a képernyőre lesz írva. Ezután BeginPeek a rendszer ismét meghívja egy új aszinkron betekintő műveletet ugyanazzal az időtúllépéssel.

#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

Megjegyzések

Az aszinkron feldolgozás során az eseményt akkor emeli BeginPeek ki PeekCompleted , ha egy üzenet elérhetővé válik az üzenetsorban, vagy ha a megadott időintervallum lejárt.

PeekCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

A használathoz BeginPeekhozzon létre egy eseménykezelőt, amely feldolgozza az aszinkron művelet eredményeit, és társítja azt az eseménymegbízotthoz. BeginPeek aszinkron betekintő műveletet kezdeményez; a MessageQueue rendszer az esemény felemelésével PeekCompleted értesítést kap, amikor egy üzenet érkezik az üzenetsorba. Ezután MessageQueue az üzenethez hívással EndPeek(IAsyncResult) vagy az eredmény beolvasásával érheti el az üzenetet a PeekCompletedEventArgs.

A BeginPeek metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Mivel BeginPeek aszinkron, hívhatja úgy, hogy betekintsen az üzenetsorba anélkül, hogy blokkolta volna az aktuális végrehajtási szálat. Az üzenetsor szinkronizálásához használja a metódust Peek .

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

A IAsyncResult visszaadott BeginPeek érték azonosítja a metódus által elindított aszinkron műveletet. Ezt IAsyncResult a művelet teljes élettartama alatt használhatja, bár általában csak akkor használja, ha EndPeek(IAsyncResult) meghívják. Ha azonban több aszinkron műveletet indít el, az értékeket IAsyncResult elhelyezheti egy tömbben, és megadhatja, hogy várnia kell-e az összes művelet vagy bármely művelet befejezésére. Ebben az esetben a befejezett művelet azonosításához használja AsyncWaitHandle a IAsyncResult tulajdonságot.

Ez a túlterhelés időtúllépést határoz meg. Ha a timeout paraméter által megadott időköz lejár, ez az összetevő aktiválja az eseményt PeekCompleted . Mivel nincs üzenet, egy későbbi hívás kivételt fog eredményezni EndPeek(IAsyncResult) .

Ha CanRead igen false, a befejezési esemény létrejön, de a hívás EndPeek(IAsyncResult)során kivétel lép fel.

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

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

Lásd még

A következőre érvényes:

Szálbiztonság

A metódus nem szálbiztos.