MessageQueue.BeginPeek Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Messaging

Zestaw:: System.Messaging.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Inicjuje asynchroniczną operację podglądu, informując kolejkę komunikatów o rozpoczęciu podglądu komunikatu i powiadamianiu programu obsługi zdarzeń po zakończeniu.

Przeciążenia

BeginPeek(TimeSpan, Object, AsyncCallback)	Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w całym okresie istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
BeginPeek(TimeSpan, Object)	Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w całym okresie istnienia operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i używa określonego kursora, określonej akcji podglądu i określonego obiektu stanu. Obiekt stanu udostępnia skojarzone informacje przez cały okres istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
BeginPeek()	Inicjuje asynchroniczną operację podglądu, która nie ma limitu czasu. Operacja nie zostanie ukończona, dopóki komunikat nie stanie się dostępny w kolejce.
BeginPeek(TimeSpan)	Inicjuje asynchroniczną operację podglądu, która ma określony limit czasu. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

BeginPeek(TimeSpan, Object, AsyncCallback)

Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w całym okresie istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

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

Element TimeSpan wskazujący interwał czasu oczekiwania na udostępnienie komunikatu.

stateObject: Object

Obiekt stanu określony przez aplikację, który zawiera informacje skojarzone z operacją asynchroniczną.

callback: AsyncCallback

Element AsyncCallback , który otrzyma powiadomienie o zakończeniu operacji asynchronicznej.

Zwraca

IAsyncResult

Element IAsyncResult identyfikujący wysłaną asynchroniczną prośbę.

Wyjątki

ArgumentException

Wartość określona dla parametru timeout jest nieprawidłowa.

MessageQueueException

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu tworzy asynchroniczną operację wglądu. Przykładowy kod wysyła komunikat do lokalnej kolejki komunikatów, a następnie wywołuje BeginPeek(TimeSpan, Object, AsyncCallback)metodę , przekazując: wartość limitu czasu wynoszącą dziesięć sekund; unikatową liczbę całkowitą, która identyfikuje ten konkretny komunikat, oraz nowe wystąpienie, które identyfikuje procedurę obsługi zdarzeńAsyncCallback. MyPeekCompleted PeekCompleted Po wystąpieniu zdarzenia program obsługi zdarzeń wyświetla komunikat i zapisuje treść komunikatu oraz identyfikator komunikatu całkowitego na ekranie.

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

Uwagi

Gdy używasz tego przeciążenia, wywołanie zwrotne określone w parametrze wywołania zwrotnego jest wywoływane bezpośrednio, gdy komunikat stanie się dostępny w kolejce lub gdy określony interwał czasu wygasł; zdarzenie PeekCompleted nie jest zgłaszane. Inne przeciążenia polegają na tym składniku BeginPeek PeekCompleted w celu podniesienia zdarzenia.

PeekCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Metoda BeginPeek zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginPeek jest asynchroniczna, można ją wywołać, aby zajrzeć do kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie zajrzeć do kolejki, użyj Peek metody .

Po zakończeniu operacji asynchronicznej można wywołać program BeginPeek obsługi zdarzeń lub BeginReceive ponownie, aby otrzymywać powiadomienia.

BeginPeek Zwraca element IAsyncResult identyfikujący operację asynchroniczną uruchomioną przez metodę. Można go IAsyncResult używać przez cały okres istnienia operacji, chociaż zazwyczaj nie używasz jej do EndPeek(IAsyncResult) momentu wywołania. Jeśli jednak rozpoczniesz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy zaczekać na ukończenie wszystkich operacji, czy jakąkolwiek operację. W takim przypadku należy użyć AsyncWaitHandle właściwości elementu IAsyncResult , aby zidentyfikować ukończoną operację.

Obiekt stanu kojarzy informacje o stanie z operacją. Jeśli na przykład wywołasz wiele BeginPeek razy w celu zainicjowania wielu operacji, możesz zidentyfikować każdą operację za pomocą oddzielnego obiektu stanu, który definiujesz.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i formatu bezpośredniego	Tak

Zobacz też

Dotyczy

BeginPeek(TimeSpan, Object)

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

Element TimeSpan wskazujący interwał czasu oczekiwania na udostępnienie komunikatu.

stateObject: Object

Obiekt stanu określony przez aplikację, który zawiera informacje skojarzone z operacją asynchroniczną.

Zwraca

IAsyncResult

Element IAsyncResult identyfikujący wysłaną asynchroniczną prośbę.

Wyjątki

ArgumentException

Wartość określona dla parametru timeout jest nieprawidłowa.

MessageQueueException

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu tworzy asynchroniczną operację wglądu przy użyciu ścieżki kolejki ".\myQueue". Tworzy on procedurę obsługi MyPeekCompletedzdarzeń i dołącza ją do delegata PeekCompleted procedury obsługi zdarzeń. BeginPeek jest wywoływana, z limitem czasu w ciągu jednej minuty. Każde wywołanie metody ma BeginPeek unikatową skojarzną liczbę całkowitą, która identyfikuje tę konkretną operację. Gdy PeekCompleted zdarzenie zostanie podniesione lub upłynął limit czasu, komunikat, jeśli istnieje, zostanie pobrany, a jego treść oraz identyfikator liczby całkowitej specyficznej dla operacji zostaną zapisane na ekranie. Następnie BeginPeek jest wywoływany ponownie, aby zainicjować nową operację asynchroniczną z tym samym limitem czasu i skojarzona liczba całkowita właśnie ukończonej operacji.

#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

Uwagi

W przypadku przetwarzania asynchronicznego należy użyć BeginPeek polecenia , aby zgłosić PeekCompleted zdarzenie, gdy komunikat stanie się dostępny w kolejce lub gdy określony interwał czasu wygasł.

PeekCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Użyj tego przeciążenia, aby skojarzyć informacje z operacją, która zostanie zachowana przez cały okres istnienia operacji. Program obsługi zdarzeń może uzyskać dostęp do tych informacji, przeglądając AsyncState właściwość IAsyncResult obiektu skojarzonego z operacją.

Aby użyć BeginPeekmetody , utwórz procedurę obsługi zdarzeń, która przetwarza wyniki operacji asynchronicznej i skojarz ją z delegatem zdarzenia. BeginPeek inicjuje operację asynchronicznego wglądu; komunikat MessageQueue jest powiadamiany przez podniesienie PeekCompleted zdarzenia po nadejściu komunikatu w kolejce. Następnie MessageQueue może uzyskać dostęp do komunikatu przez wywołanie EndPeek(IAsyncResult) lub pobranie wyniku przy użyciu polecenia PeekCompletedEventArgs.

Metoda BeginPeek zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginPeek jest asynchroniczna, można ją wywołać, aby zajrzeć do kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie zajrzeć do kolejki, użyj Peek metody .

Po zakończeniu operacji asynchronicznej można wywołać program BeginPeek obsługi zdarzeń lub BeginReceive ponownie, aby otrzymywać powiadomienia.

To przeciążenie określa limit czasu i obiekt stanu. Jeśli interwał określony przez timeout parametr wygaśnie, ten składnik zgłasza PeekCompleted zdarzenie. Ponieważ żaden komunikat nie istnieje, kolejne wywołanie wywołania EndPeek(IAsyncResult) zgłosi wyjątek.

Można również użyć obiektu stanu, aby przekazać informacje między wątkami procesu. Jeśli wątek zostanie uruchomiony, ale wywołanie zwrotne znajduje się w innym wątku w scenariuszu asynchronicznym, obiekt stanu jest marshalowany i przekazywany z powrotem wraz z informacjami z zdarzenia.

Jeśli CanRead jest to false, zostanie zgłoszone zdarzenie ukończenia, ale podczas wywoływania EndPeek(IAsyncResult)polecenia zostanie zgłoszony wyjątek .

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i formatu bezpośredniego	Tak

Zobacz też

Dotyczy

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

Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i używa określonego kursora, określonej akcji podglądu i określonego obiektu stanu. Obiekt stanu udostępnia skojarzone informacje przez cały okres istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

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

Element TimeSpan wskazujący interwał czasu oczekiwania na udostępnienie komunikatu.

cursor: Cursor

Element Cursor , który utrzymuje określoną pozycję w kolejce komunikatów.

action: PeekAction

Jedna z PeekAction wartości. Wskazuje, czy zajrzeć do bieżącego komunikatu w kolejce, czy następnego komunikatu.

state: Object

Obiekt stanu określony przez aplikację, który zawiera informacje skojarzone z operacją asynchroniczną.

callback: AsyncCallback

Element AsyncCallback , który otrzymuje powiadomienie o zakończeniu operacji asynchronicznej.

Zwraca

IAsyncResult

Element IAsyncResult identyfikujący wysłaną asynchroniczną prośbę.

Wyjątki

ArgumentOutOfRangeException

Wartość inna niż PeekAction.Current lub PeekAction.Next została określona dla parametru action .

ArgumentNullException

Parametr cursor to null.

ArgumentException

Wartość określona dla parametru timeout jest nieprawidłowa.

MessageQueueException

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Uwagi

Gdy używasz tego przeciążenia, wywołanie zwrotne określone w parametrze wywołania zwrotnego jest wywoływane bezpośrednio, gdy komunikat stanie się dostępny w kolejce lub gdy określony interwał czasu wygasł. Zdarzenie PeekCompleted nie jest zgłaszane. Inne przeciążenia polegają na tym składniku BeginPeek PeekCompleted w celu podniesienia zdarzenia.

PeekCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Metoda BeginPeek zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginPeek jest asynchroniczna, można ją wywołać, aby zajrzeć do kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie zajrzeć do kolejki, użyj Peek metody .

Po zakończeniu operacji asynchronicznej można wywołać program BeginPeek obsługi zdarzeń lub BeginReceive ponownie, aby otrzymywać powiadomienia.

BeginPeek Zwraca element IAsyncResult identyfikujący operację asynchroniczną rozpoczętą przez metodę . Można go IAsyncResult używać przez cały okres istnienia operacji, chociaż zazwyczaj nie używasz jej do EndPeek(IAsyncResult) momentu wywołania. Jeśli jednak rozpoczniesz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy zaczekać na ukończenie wszystkich operacji, czy jakąkolwiek operację. W tym przypadku użyj AsyncWaitHandle właściwości elementu IAsyncResult , aby zidentyfikować ukończoną operację.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i formatu bezpośredniego	Tak

Zobacz też

Dotyczy

BeginPeek()

Inicjuje asynchroniczną operację podglądu, która nie ma limitu czasu. Operacja nie zostanie ukończona, dopóki komunikat nie stanie się dostępny w kolejce.

public:
 IAsyncResult ^ BeginPeek();

public IAsyncResult BeginPeek ();

member this.BeginPeek : unit -> IAsyncResult

Public Function BeginPeek () As IAsyncResult

Zwraca

IAsyncResult

Element IAsyncResult identyfikujący wysłaną asynchroniczną prośbę.

Wyjątki

MessageQueueException

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu tworzy procedurę obsługi zdarzeń o nazwie MyPeekCompleted, dołącza ją do PeekCompleted delegata procedury obsługi zdarzeń i wywołuje wywołanie BeginPeek w celu zainicjowania asynchronicznej operacji podglądu w kolejce znajdującej się w ścieżce ".\myQueue". PeekCompleted Po wyświetleniu zdarzenia przykład wyświetla komunikat i zapisuje jego treść na ekranie. W tym przykładzie zostanie ponownie wywołana BeginPeek metoda inicjowania nowej operacji asynchronicznej.

#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

Uwagi

W przypadku przetwarzania asynchronicznego należy użyć BeginPeek polecenia , aby zgłosić PeekCompleted zdarzenie, gdy komunikat stanie się dostępny w kolejce.

PeekCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Metoda BeginPeek zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginPeek jest asynchroniczna, można ją wywołać, aby zajrzeć do kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie zajrzeć do kolejki, użyj Peek metody .

Po zakończeniu operacji asynchronicznej można wywołać program BeginPeek obsługi zdarzeń lub BeginReceive ponownie, aby otrzymywać powiadomienia.

Funkcja IAsyncResult , która BeginPeek zwraca, identyfikuje operację asynchroniczną uruchomioną przez metodę. Można go IAsyncResult używać przez cały okres istnienia operacji, chociaż zazwyczaj nie używasz jej do EndPeek(IAsyncResult) momentu wywołania. Jeśli jednak rozpoczniesz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy zaczekać na ukończenie wszystkich operacji, czy jakąkolwiek operację. W takim przypadku należy użyć AsyncWaitHandle właściwości elementu IAsyncResult , aby zidentyfikować ukończoną operację.

Jeśli CanRead jest to false, zostanie zgłoszone zdarzenie ukończenia, ale podczas wywoływania EndPeek(IAsyncResult)polecenia zostanie zgłoszony wyjątek .

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i formatu bezpośredniego	Tak

Zobacz też

Dotyczy

BeginPeek(TimeSpan)

Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.

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

Element TimeSpan wskazujący interwał czasu oczekiwania na udostępnienie komunikatu.

Zwraca

IAsyncResult

Element IAsyncResult , który identyfikuje przesłane żądanie asynchroniczne.

Wyjątki

ArgumentException

Wartość określona dla parametru timeout jest nieprawidłowa.

MessageQueueException

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu tworzy asynchroniczną operację wglądu przy użyciu ścieżki kolejki ".\myQueue". Tworzy on procedurę obsługi MyPeekCompletedzdarzeń i dołącza ją do delegata PeekCompleted procedury obsługi zdarzeń. BeginPeek jest wywoływana z limitem czasu na minutę, aby zainicjować operację asynchroniczną wglądu. PeekCompleted Gdy zdarzenie zostanie podniesione lub upłynął limit czasu, komunikat zostanie pobrany, jeśli istnieje, a jego treść zostanie zapisana na ekranie. Następnie BeginPeek jest wywoływana ponownie, aby zainicjować nową asynchroniczną operację podglądu z tym samym limitem czasu.

#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

Uwagi

PeekCompleted jest również zgłaszany, jeśli komunikat już istnieje w kolejce.

Metoda BeginPeek zwraca natychmiast, ale operacja asynchroniczna nie zostanie ukończona, dopóki nie zostanie wywołana procedura obsługi zdarzeń.

Ponieważ BeginPeek jest asynchroniczna, można ją wywołać, aby zajrzeć do kolejki bez blokowania bieżącego wątku wykonywania. Aby synchronicznie zajrzeć do kolejki, użyj Peek metody .

Po zakończeniu operacji asynchronicznej można wywołać program BeginPeek obsługi zdarzeń lub BeginReceive ponownie, aby otrzymywać powiadomienia.

Funkcja IAsyncResult , która BeginPeek zwraca, identyfikuje operację asynchroniczną uruchomioną przez metodę. Można go IAsyncResult używać przez cały okres istnienia operacji, chociaż zazwyczaj nie używasz jej do EndPeek(IAsyncResult) momentu wywołania. Jeśli jednak rozpoczniesz kilka operacji asynchronicznych, możesz umieścić ich IAsyncResult wartości w tablicy i określić, czy zaczekać na ukończenie wszystkich operacji, czy jakąkolwiek operację. W tym przypadku użyjesz AsyncWaitHandle właściwości , IAsyncResult aby zidentyfikować ukończoną operację.

To przeciążenie określa limit czasu. Jeśli interwał określony przez timeout parametr wygaśnie, ten składnik zgłasza PeekCompleted zdarzenie. Ponieważ żaden komunikat nie istnieje, kolejne wywołanie EndPeek(IAsyncResult) metody zgłosi wyjątek.

Jeśli CanRead parametr ma falsewartość , zdarzenie ukończenia zostanie zgłoszone, ale podczas wywoływania EndPeek(IAsyncResult)metody zostanie zgłoszony wyjątek .

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Nazwa komputera lokalnego i bezpośredniego formatu	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i bezpośredniego formatu	Tak

Zobacz też

Dotyczy

Bezpieczeństwo wątkowe

Metoda nie jest bezpieczna wątkiem.

Udostępnij za pośrednictwem

MessageQueue.BeginPeek Metoda

Definicja

Przeciążenia

BeginPeek(TimeSpan, Object, AsyncCallback)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

BeginPeek(TimeSpan, Object)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

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

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

BeginPeek()

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

BeginPeek(TimeSpan)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Bezpieczeństwo wątkowe

Dodatkowe zasoby