Sdílet prostřednictvím

MessageQueue.BeginPeek Metoda

  • Reference

Definice

Obor názvů:
System.Messaging
Sestavení:
System.Messaging.dll

Inicializuje operaci asynchronního náhledu tím, že službě Řízení front zpráv oznámí, že má začít prohlédnout zprávu a po dokončení upozornit obslužnou rutinu události.

Přetížení

BeginPeek(TimeSpan, Object, AsyncCallback)

Inicializuje asynchronní operaci náhledu, která má zadaný časový limit a zadaný objekt stavu, který poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží prostřednictvím zpětného volání oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginPeek(TimeSpan, Object)

Inicializuje asynchronní operaci náhledu, která má zadaný časový limit a zadaný objekt stavu, který poskytuje přidružené informace po celou dobu životnosti operace. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Inicializuje asynchronní operaci náhledu, která má zadaný časový limit a která používá zadaný kurzor, zadanou akci náhledu a zadaný objekt stavu. Objekt stavu poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží prostřednictvím zpětného volání oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginPeek()

Inicializuje asynchronní operaci náhledu, která nemá žádný časový limit. Operace není dokončena, dokud nebude ve frontě k dispozici zpráva.
BeginPeek(TimeSpan)

Inicializuje asynchronní operaci náhledu, která má zadaný časový limit. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.

BeginPeek(TimeSpan, Object, AsyncCallback)

Inicializuje asynchronní operaci náhledu, která má zadaný časový limit a zadaný objekt stavu, který poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží prostřednictvím zpětného volání oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.

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

Parametry

timeout
TimeSpan

A TimeSpan označující interval čekání na zpřístupnění zprávy.

stateObject
Object

Objekt stavu určený aplikací, který obsahuje informace přidružené k asynchronní operaci.

callback
AsyncCallback

Objekt AsyncCallback , který obdrží oznámení o dokončení asynchronní operace.

Návraty

IAsyncResult

Ten IAsyncResult , který identifikuje publikovaný asynchronní požadavek.

Výjimky

ArgumentException

Hodnota zadaná pro timeout parametr není platná.

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Příklady

Následující příklad kódu vytvoří asynchronní operaci náhledu. Příklad kódu odešle zprávu do místní fronty zpráv, pak zavolá BeginPeek(TimeSpan, Object, AsyncCallback), předání: hodnotu časového limitu deset sekund; jedinečné celé číslo, které identifikuje danou konkrétní zprávu; a novou instanci AsyncCallback , která identifikuje obslužnou rutinu události, MyPeekCompleted. Při vyvolání PeekCompleted události obslužná rutina události nahlédne do zprávy a zapíše text zprávy a identifikátor celé zprávy na obrazovku.

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

Poznámky

Když použijete toto přetížení, zpětné volání zadané v parametru zpětného volání je vyvoláno přímo, když zpráva bude k dispozici ve frontě nebo když vypršela zadaný interval časového intervalu; událost PeekCompleted není vyvolána. Další přetížení BeginPeek závisí na této komponentě, aby vyvolala PeekCompleted událost.

PeekCompleted vyvolá se také v případě, že ve frontě již existuje zpráva.

Metoda BeginPeek vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat a zobrazit frontu bez blokování aktuálního vlákna provádění. Pokud chcete synchronně zobrazit frontu, použijte metodu Peek .

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste dál dostávali oznámení.

BeginPeek vrátí hodnotu IAsyncResult , která identifikuje asynchronní operaci, kterou metoda spustila. Můžete ho používat IAsyncResult po celou dobu životnosti operace, i když ji obvykle nepoužíváte, dokud EndPeek(IAsyncResult) se nevolá. Pokud však spustíte několik asynchronních operací, můžete jejich IAsyncResult hodnoty umístit do pole a určit, zda se mají čekat na dokončení všech operací nebo jakékoli operace. V tomto případě použijete AsyncWaitHandle vlastnost objektu IAsyncResult k identifikaci dokončené operace.

Objekt stavu přidruží informace o stavu k operaci. Pokud například zavoláte BeginPeek vícekrát, abyste zahájili více operací, můžete každou operaci identifikovat prostřednictvím samostatného objektu stavu, který definujete.

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny K dispozici.
Místní počítač Yes
Název místního počítače a přímého formátu Yes
Vzdálený počítač No
Název vzdáleného počítače a přímého formátu Yes

Viz také

Platí pro

BeginPeek(TimeSpan, Object)

Inicializuje asynchronní operaci náhledu, která má zadaný časový limit a zadaný objekt stavu, který poskytuje přidružené informace po celou dobu životnosti operace. Operace není dokončena, dokud zpráva nebude k dispozici ve frontě nebo dokud nedojde k vypršení časového limitu.

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

Parametry

timeout
TimeSpan

A TimeSpan označující interval čekání na zpřístupnění zprávy.

stateObject
Object

Objekt stavu určený aplikací, který obsahuje informace přidružené k asynchronní operaci.

Návraty

IAsyncResult

, IAsyncResult který identifikuje zaúčtované asynchronní požadavek.

Výjimky

ArgumentException

Hodnota zadaná pro timeout parametr není platná.

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Příklady

Následující příklad kódu vytvoří operaci asynchronního náhledu pomocí cesty fronty .\myQueue. Vytvoří obslužnou rutinu MyPeekCompletedudálosti a připojí ji k delegátovi PeekCompleted obslužné rutiny události. BeginPeek se volá s časovým limitem jedné minuty. Každé volání BeginPeek má jedinečné celé číslo, které identifikuje danou konkrétní operaci. Když dojde k vyvolání PeekCompleted události nebo vypršení časového limitu, načte se zpráva( pokud existuje) a její tělo a celočíselný identifikátor specifický pro operaci se zapíše na obrazovku. Pak BeginPeek se znovu zavolá, aby se zahájila nová operace asynchronního náhledu se stejným vypršením časového limitu a přidruženým číslem právě dokončené operace.

#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

Poznámky

Při asynchronním zpracování se používá BeginPeek k vyvolání PeekCompleted události při zpřístupnění zprávy ve frontě nebo při vypršení zadaného časového intervalu.

PeekCompleted vyvolá se také v případě, že ve frontě již existuje zpráva.

Toto přetížení slouží k přidružení informací k operaci, která se zachová po celou dobu životnosti operace. Obslužná rutina události má přístup k tomuto informacím tak, že se podívá na AsyncState vlastnost objektu IAsyncResult , který je přidružen k operaci.

Pokud chcete použít BeginPeek, vytvořte obslužnou rutinu události, která zpracovává výsledky asynchronní operace a přidružte ji k delegátovi události. BeginPeek inicializuje asynchronní operaci náhledu; je MessageQueue prostřednictvím vyvolání PeekCompleted události upozorněn, když do fronty dorazí zpráva. Potom MessageQueue může ke zprávě získat přístup voláním EndPeek(IAsyncResult) nebo načtením výsledku PeekCompletedEventArgspomocí .

Metoda BeginPeek vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat a zobrazit frontu bez blokování aktuálního vlákna provádění. Pokud chcete synchronně zobrazit frontu, použijte metodu Peek .

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste dál dostávali oznámení.

BeginPeek vrátí hodnotu IAsyncResult , která identifikuje asynchronní operaci, kterou metoda spustila. Můžete ho používat IAsyncResult po celou dobu životnosti operace, i když ji obvykle nepoužíváte, dokud EndPeek(IAsyncResult) se nevolá. Pokud však spustíte několik asynchronních operací, můžete jejich IAsyncResult hodnoty umístit do pole a určit, zda se mají čekat na dokončení všech operací nebo jakékoli operace. V tomto případě použijete AsyncWaitHandle vlastnost objektu IAsyncResult k identifikaci dokončené operace.

Toto přetížení určuje časový limit a objekt stavu. Pokud interval určený parametrem timeout vyprší, tato komponenta PeekCompleted vyvolá událost. Vzhledem k tomu, že neexistuje žádná zpráva, vyvolá následné volání EndPeek(IAsyncResult) výjimku.

Objekt stavu přidruží informace o stavu k operaci. Pokud například zavoláte BeginPeek vícekrát, abyste zahájili více operací, můžete každou operaci identifikovat prostřednictvím samostatného objektu stavu, který definujete. Obrázek tohoto scénáře najdete v části Příklad.

Objekt stavu můžete také použít k předávání informací mezi vlákny procesu. Pokud je vlákno spuštěno, ale zpětné volání je v jiném vlákně v asynchronním scénáři, stavový objekt je zařazován a předán zpět spolu s informacemi z události.

Pokud CanRead je false, dojde k vyvolání události dokončení, ale při volání EndPeek(IAsyncResult)se vyvolá výjimka .

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny K dispozici.
Místní počítač Yes
Název místního počítače a přímého formátu Yes
Vzdálený počítač No
Název vzdáleného počítače a přímého formátu Yes

Viz také

Platí pro

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

Inicializuje asynchronní operaci náhledu, která má zadaný časový limit a která používá zadaný kurzor, zadanou akci náhledu a zadaný objekt stavu. Objekt stavu poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení prostřednictvím zpětného volání obdrží oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud zpráva nebude k dispozici ve frontě nebo dokud nedojde k vypršení časového limitu.

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

Parametry

timeout
TimeSpan

Hodnota TimeSpan označující časový interval čekání na zpřístupnění zprávy.

cursor
Cursor

A Cursor , který udržuje určitou pozici ve frontě zpráv.

action
PeekAction

Jedna z PeekAction hodnot. Určuje, zda se má zobrazit aktuální zpráva ve frontě nebo další zpráva.

state
Object

Objekt stavu určený aplikací, který obsahuje informace související s asynchronní operací.

callback
AsyncCallback

Objekt AsyncCallback , který obdrží oznámení o dokončení asynchronní operace.

Návraty

IAsyncResult

, IAsyncResult který identifikuje zaúčtované asynchronní požadavek.

Výjimky

ArgumentOutOfRangeException

Pro parametr byla zadána action jiná hodnota než PeekAction.Current nebo PeekAction.Next .

ArgumentNullException

Parametr cursor je null.

ArgumentException

Hodnota zadaná pro timeout parametr není platná.

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Poznámky

Při použití tohoto přetížení je zpětné volání zadané v parametru zpětného volání vyvoláno přímo při zpřístupnění zprávy ve frontě nebo po vypršení zadaného časového intervalu. Událost PeekCompleted není vyvolána. Ostatní přetížení BeginPeek spoléhají na tuto komponentu k vyvolání PeekCompleted události.

PeekCompleted vyvolá se také v případě, že zpráva již ve frontě existuje.

Metoda BeginPeek vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat, abyste se mohli podívat na frontu, aniž byste blokovali aktuální vlákno provádění. K synchronnímu náhledu fronty použijte metodu Peek .

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste mohli dál přijímat oznámení.

BeginPeek vrátí hodnotu , IAsyncResult která identifikuje asynchronní operaci spuštěnou metodou . Můžete ji IAsyncResult používat po celou dobu životnosti operace, i když ji obvykle nepoužíváte, dokud EndPeek(IAsyncResult) ji nezavoláte. Pokud však spustíte několik asynchronních operací, můžete jejich IAsyncResult hodnoty umístit do pole a určit, zda se mají čekat na dokončení všech operací nebo jakékoli operace. V takovém případě použijte AsyncWaitHandle vlastnost k IAsyncResult identifikaci dokončené operace.

Objekt stavu přidruží k operaci informace o stavu. Pokud například voláte BeginPeek vícekrát za účelem zahájení více operací, můžete každou operaci identifikovat prostřednictvím samostatného objektu stavu, který definujete.

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny K dispozici.
Místní počítač Yes
Název místního počítače a přímého formátu Yes
Vzdálený počítač No
Název vzdáleného počítače a přímého formátu Yes

Viz také

Platí pro

BeginPeek()

Inicializuje asynchronní operaci náhledu, která nemá žádný časový limit. Operace není dokončena, dokud zpráva nebude k dispozici ve frontě.

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

Návraty

IAsyncResult

, IAsyncResult který identifikuje zaúčtované asynchronní požadavek.

Výjimky

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Příklady

Následující příklad kódu vytvoří obslužnou rutinu události s názvem MyPeekCompleted, připojí ji k PeekCompleted delegátu obslužné rutiny události a volá BeginPeek k zahájení asynchronní operace náhledu ve frontě, která je umístěna v cestě ".\myQueue". Při vyvolání PeekCompleted události se v příkladu zobrazí náhled zprávy a její text se zapíše na obrazovku. Příklad pak zavolá BeginPeek znovu, aby se spustila nová asynchronní operace náhledu.

#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

Poznámky

V asynchronním zpracování se používá BeginPeek k vyvolání PeekCompleted události, když se zpráva zpřístupní ve frontě.

PeekCompleted vyvolá se také v případě, že zpráva již ve frontě existuje.

Pokud chcete použít BeginPeek, vytvořte obslužnou rutinu události, která zpracuje výsledky asynchronní operace a přidruží ji k delegátovi události. BeginPeek iniciuje asynchronní operaci náhledu; je MessageQueue upozorněn prostřednictvím vyvolání PeekCompleted události, když do fronty dorazí zpráva. Pak MessageQueue může získat přístup ke zprávě voláním EndPeek(IAsyncResult) nebo načtením výsledku PeekCompletedEventArgspomocí .

Metoda BeginPeek vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat, abyste se mohli podívat na frontu, aniž byste blokovali aktuální vlákno provádění. K synchronnímu náhledu fronty použijte metodu Peek .

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste mohli dál přijímat oznámení.

BeginPeek Vrácený IAsyncResult objekt identifikuje asynchronní operaci, kterou metoda spustila. Můžete ji IAsyncResult používat po celou dobu životnosti operace, i když ji obvykle nepoužíváte, dokud EndPeek(IAsyncResult) ji nezavoláte. Pokud však spustíte několik asynchronních operací, můžete jejich IAsyncResult hodnoty umístit do pole a určit, zda se mají čekat na dokončení všech operací nebo jakékoli operace. V takovém případě použijete AsyncWaitHandle vlastnost k IAsyncResult identifikaci dokončené operace.

Pokud CanRead je false, vyvolá se událost dokončení, ale při volání EndPeek(IAsyncResult)se vyvolá výjimka .

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny K dispozici.
Místní počítač Yes
Název místního počítače a přímého formátu Yes
Vzdálený počítač No
Název vzdáleného počítače a přímého formátu Yes

Viz také

Platí pro

BeginPeek(TimeSpan)

Inicializuje asynchronní operaci náhledu, která má zadaný časový limit. Operace není dokončena, dokud zpráva nebude k dispozici ve frontě nebo dokud nedojde k vypršení časového limitu.

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

Parametry

timeout
TimeSpan

Hodnota TimeSpan označující časový interval čekání na zpřístupnění zprávy.

Návraty

IAsyncResult

, IAsyncResult který identifikuje zaúčtované asynchronní požadavek.

Výjimky

ArgumentException

Hodnota zadaná pro timeout parametr není platná.

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Příklady

Následující příklad kódu vytvoří asynchronní operaci náhledu pomocí cesty fronty ".\myQueue". Vytvoří obslužnou rutinu MyPeekCompletedudálosti a připojí ji k delegátovi obslužné PeekCompleted rutiny události. BeginPeek se volá s časovým limitem jedné minuty, aby se spustila operace asynchronního náhledu. Když dojde k vyvolání PeekCompleted události nebo vypršení časového limitu, zpráva se načte, pokud existuje, a její tělo se zapíše na obrazovku. Potom BeginPeek se znovu zavolá, aby se spustila nová asynchronní operace náhledu se stejným časovým limitem.

#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

Poznámky

Při asynchronním zpracování se používá BeginPeek k vyvolání PeekCompleted události, když se zpráva zpřístupní ve frontě nebo když vyprší zadaný časový interval.

PeekCompleted vyvolá se také v případě, že zpráva již ve frontě existuje.

Pokud chcete použít BeginPeek, vytvořte obslužnou rutinu události, která zpracuje výsledky asynchronní operace a přidruží ji k delegátovi události. BeginPeek iniciuje asynchronní operaci náhledu; je MessageQueue upozorněn prostřednictvím vyvolání PeekCompleted události, když do fronty dorazí zpráva. Pak MessageQueue může získat přístup ke zprávě voláním EndPeek(IAsyncResult) nebo načtením výsledku PeekCompletedEventArgspomocí .

Metoda BeginPeek vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat, abyste se mohli podívat na frontu, aniž byste blokovali aktuální vlákno provádění. K synchronnímu náhledu fronty použijte metodu Peek .

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste mohli dál přijímat oznámení.

BeginPeek Vrácený IAsyncResult objekt identifikuje asynchronní operaci, kterou metoda spustila. Můžete ji IAsyncResult používat po celou dobu životnosti operace, i když ji obvykle nepoužíváte, dokud EndPeek(IAsyncResult) ji nezavoláte. Pokud však spustíte několik asynchronních operací, můžete jejich IAsyncResult hodnoty umístit do pole a určit, zda se mají čekat na dokončení všech operací nebo jakékoli operace. V takovém případě použijete AsyncWaitHandle vlastnost k IAsyncResult identifikaci dokončené operace.

Toto přetížení určuje časový limit. Pokud interval určený parametrem timeout vyprší, vyvolá tato komponenta PeekCompleted událost. Vzhledem k tomu, že žádná zpráva neexistuje, vyvolá následné volání EndPeek(IAsyncResult) výjimku.

Pokud CanRead je false, vyvolá se událost dokončení, ale při volání EndPeek(IAsyncResult)se vyvolá výjimka .

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny K dispozici.
Místní počítač Yes
Název místního počítače a přímého formátu Yes
Vzdálený počítač No
Název vzdáleného počítače a přímého formátu Yes

Viz také

Platí pro

Bezpečný přístup z více vláken

Metoda není bezpečná pro přístup z více vláken.