MessageQueue.BeginPeek Metoda

Definice

Obor názvů:: System.Messaging

Sestavení:: System.Messaging.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Inicializuje asynchronní náhled operace tím, že sdělí službě Řízení front zpráv, aby začal náhled zprávy a upozorňovat obslužnou rutinu události po dokončení.

Přetížení

Name	Description
BeginPeek(TimeSpan, Object, AsyncCallback)	Inicializuje asynchronní náhled operace, která má zadaný časový limit a zadaný stav objekt, který poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží oznámení prostřednictvím zpětného volání identity obslužné rutiny události pro operaci. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginPeek(TimeSpan, Object)	Inicializuje asynchronní náhled operace, která má zadaný časový limit a zadaný stav objekt, který poskytuje přidružené informace po celou dobu životnosti operace. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Inicializuje asynchronní náhled operace, která má zadaný časový limit a používá zadaný kurzor, zadanou náhledovou akci a zadaný stavový objekt. Objekt stavu poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží oznámení prostřednictvím zpětného volání identity obslužné rutiny události pro operaci. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginPeek()	Inicializuje asynchronní náhled operace, která nemá časový limit. Operace není dokončena, dokud se ve frontě nezobrazí zpráva.
BeginPeek(TimeSpan)	Inicializuje asynchronní náhled operace, která má zadaný časový limit. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.

BeginPeek(TimeSpan, Object, AsyncCallback)

Inicializuje asynchronní náhled operace, která má zadaný časový limit a zadaný stav objekt, který poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží oznámení prostřednictvím zpětného volání identity obslužné rutiny události pro operaci. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde 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

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

stateObject: Object

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

callback: AsyncCallback

Tím AsyncCallback se zobrazí oznámení o dokončení asynchronní operace.

Návraty

IAsyncResult

Ten IAsyncResult identifikuje publikovaný asynchronní požadavek.

Výjimky

ArgumentException

Hodnota zadaná pro parametr timeout není platná.

MessageQueueException

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

Příklady

Následující příklad kódu vytvoří asynchronní náhled operace. Příklad kódu odešle zprávu do místní fronty zpráv a pak volá BeginPeek(TimeSpan, Object, AsyncCallback), předává: hodnotu časového limitu deset sekund; jedinečné celé číslo, které identifikuje tuto konkrétní zprávu; a novou instanciAsyncCallback, která identifikuje obslužnou rutinu události. MyPeekCompleted PeekCompleted Při vyvolání události obslužná rutina události zobrazí náhled 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

Pokud použijete toto přetížení, zpětné volání zadané v parametru zpětného volání je vyvoláno přímo při zpřístupnění zprávy ve frontě nebo v případě vypršení zadaného intervalu času; PeekCompleted událost není vyvolána. Další přetížení BeginPeek spoléhá na tuto komponentu k vyvolání PeekCompleted události.

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

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

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat k náhledu fronty bez blokování aktuálního vlákna 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 přijímat oznámení.

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

Objekt stavu přidruží informace o stavu k operaci. 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č	Ano
Název místního počítače a přímého formátu	Ano
Vzdálený počítač	Ne
Název vzdáleného počítače a přímého formátu	Ano

Viz také

Platí pro

BeginPeek(TimeSpan, Object)

Inicializuje asynchronní náhled operace, která má zadaný časový limit a zadaný stav objekt, který poskytuje přidružené informace po celou dobu životnosti operace. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde 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

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

stateObject: Object

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

Návraty

IAsyncResult

Ten IAsyncResult identifikuje publikovaný asynchronní požadavek.

Výjimky

ArgumentException

Hodnota zadaná pro parametr timeout není platná.

MessageQueueException

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

Příklady

Následující příklad kódu vytvoří asynchronní náhled operace pomocí cesty fronty ".\myQueue". Vytvoří obslužnou rutinu MyPeekCompletedudálosti a připojí ji k delegátu PeekCompleted obslužné rutiny události. BeginPeek je volána s časovým limitem jedné minuty. Každé volání BeginPeek má jedinečné celé číslo, které identifikuje danou konkrétní operaci. PeekCompleted Při vyvolání události nebo vypršení časového limitu se načte zpráva, pokud existuje, a její text a identifikátor celého čísla specifického pro operaci se zapíše na obrazovku. Potom BeginPeek se znovu zavolá, aby se spustila nová asynchronní operace náhledu se stejným časovým limitem a přidruženým celé číslo 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í použijete BeginPeek k vyvolání PeekCompleted události, když bude zpráva k dispozici ve frontě nebo když vypršel zadaný interval času.

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

Toto přetížení použijte 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 IAsyncResult , která je přidružena k operaci.

Chcete-li 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í náhled operace; při MessageQueue příchodu PeekCompleted zprávy do fronty se zobrazí oznámení prostřednictvím vyvolání události. K MessageQueue této zprávě pak může přistupovat voláním EndPeek(IAsyncResult) nebo načtením výsledku pomocí příkazu PeekCompletedEventArgs.

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

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat k náhledu fronty bez blokování aktuálního vlákna 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 přijímat oznámení.

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

Objekt stavu můžete také použít k předávání informací napříč 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 se zařazuje a předává zpět spolu s informacemi z události.

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

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č	Ano
Název místního počítače a přímého formátu	Ano
Vzdálený počítač	Ne
Název vzdáleného počítače a přímého formátu	Ano

Viz také

Platí pro

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

Inicializuje asynchronní náhled operace, která má zadaný časový limit a používá zadaný kurzor, zadanou náhledovou akci a zadaný stavový objekt. Objekt stavu poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží oznámení prostřednictvím zpětného volání identity obslužné rutiny události pro operaci. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde 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í interval doby č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, jestli se má zobrazit aktuální zpráva ve frontě, nebo jestli se má zobrazit další zpráva.

state: Object

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

callback: AsyncCallback

Tím AsyncCallback se zobrazí oznámení o dokončení asynchronní operace.

Návraty

IAsyncResult

Ten IAsyncResult identifikuje publikovaný asynchronní požadavek.

Výjimky

ArgumentOutOfRangeException

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

ArgumentNullException

Parametr cursor je null.

ArgumentException

Hodnota zadaná pro parametr timeout není platná.

MessageQueueException

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

Poznámky

Pokud použijete toto přetížení, zpětné volání zadané v parametru zpětného volání je vyvoláno přímo při zpřístupnění zprávy ve frontě nebo v případě vypršení zadaného intervalu času. Událost PeekCompleted není vyvolána. Další přetížení BeginPeek spoléhá na tuto komponentu k vyvolání PeekCompleted události.

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

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

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat k náhledu fronty bez blokování aktuálního vlákna 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 přijímat oznámení.

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

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č	Ano
Název místního počítače a přímého formátu	Ano
Vzdálený počítač	Ne
Název vzdáleného počítače a přímého formátu	Ano

Viz také

Platí pro

BeginPeek()

Inicializuje asynchronní náhled operace, která nemá časový limit. Operace není dokončena, dokud se ve frontě nezobrazí zpráva.

public:
 IAsyncResult ^ BeginPeek();

public IAsyncResult BeginPeek();

member this.BeginPeek : unit -> IAsyncResult

Public Function BeginPeek () As IAsyncResult

Návraty

IAsyncResult

Ten IAsyncResult identifikuje publikovaný asynchronní požadavek.

Výjimky

MessageQueueException

Při přístupu k metodě ří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ání BeginPeek inicializuje asynchronní náhled operace ve frontě, která je umístěna v cestě ".\myQueue". PeekCompleted Když je vyvolána událost, příklad zobrazí zprávu a zapíše její text na obrazovku. Příklad pak zavolá BeginPeek znovu, aby zahájil novou asynchronní náhledovou operaci.

#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

Při asynchronním zpracování použijete BeginPeek k vyvolání PeekCompleted události, když bude zpráva k dispozici ve frontě.

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

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

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat k náhledu fronty bez blokování aktuálního vlákna 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 přijímat oznámení.

Tato IAsyncResult BeginPeek metoda identifikuje asynchronní operaci, kterou metoda spustila. Tuto funkci můžete použít IAsyncResult po celou dobu životnosti operace, i když ji obecně nepoužíváte, dokud EndPeek(IAsyncResult) nebude volána. Pokud ale spustíte několik asynchronních operací, můžete jejich IAsyncResult hodnoty umístit do pole a určit, jestli se mají čekat na dokončení všech operací nebo jakékoli operace. V tomto případě použijete AsyncWaitHandle vlastnost k IAsyncResult identifikaci dokončené operace.

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

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č	Ano
Název místního počítače a přímého formátu	Ano
Vzdálený počítač	Ne
Název vzdáleného počítače a přímého formátu	Ano

Viz také

Platí pro

BeginPeek(TimeSpan)

Inicializuje asynchronní náhled operace, která má zadaný časový limit. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde 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í interval doby čekání na zpřístupnění zprávy.

Návraty

IAsyncResult

Ten IAsyncResult identifikuje publikovaný asynchronní požadavek.

Výjimky

ArgumentException

Hodnota zadaná pro parametr timeout není platná.

MessageQueueException

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

Příklady

Následující příklad kódu vytvoří asynchronní náhled operace pomocí cesty fronty ".\myQueue". Vytvoří obslužnou rutinu MyPeekCompletedudálosti a připojí ji k delegátu PeekCompleted obslužné rutiny události. BeginPeek se volá s časovým limitem jedné minuty, aby se spustila asynchronní operace náhledu. PeekCompleted Při vyvolání události nebo vypršení časového limitu se zpráva načte, pokud existuje, a její text 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í použijete BeginPeek k vyvolání PeekCompleted události, když bude zpráva k dispozici ve frontě nebo když vypršel zadaný interval času.

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

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

Vzhledem k tomu BeginPeek , že je asynchronní, můžete ji volat k náhledu fronty bez blokování aktuálního vlákna 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 přijímat oznámení.

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

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

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č	Ano
Název místního počítače a přímého formátu	Ano
Vzdálený počítač	Ne
Název vzdáleného počítače a přímého formátu	Ano

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.

Váš názor

Byla tato stránka užitečná?

Sdílet prostřednictvím

MessageQueue.BeginPeek Metoda

Definice

Přetížení

BeginPeek(TimeSpan, Object, AsyncCallback)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

BeginPeek(TimeSpan, Object)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

BeginPeek()

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

BeginPeek(TimeSpan)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

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

Váš názor