MessageQueue.Peek 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.

Zwraca kopię pierwszego komunikatu w kolejce bez usuwania komunikatu z kolejki.

Przeciążenia

Peek()	Zwraca wartość bez usuwania (zobacz) pierwszy komunikat w kolejce, do której odwołuje się ten MessageQueueelement . Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu.
Peek(TimeSpan)	Zwraca wartość bez usuwania (zobacz) pierwszy komunikat w kolejce, do której odwołuje się ten MessageQueueelement . Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu lub przekroczenia określonego limitu czasu.
Peek(TimeSpan, Cursor, PeekAction)	Zwraca wartość bez usuwania (wglądu) bieżącego lub następnego komunikatu w kolejce przy użyciu określonego kursora. Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu lub przekroczenia określonego limitu czasu.

Peek()

Zwraca wartość bez usuwania (zobacz) pierwszy komunikat w kolejce, do której odwołuje się ten MessageQueueelement . Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu.

public:
 System::Messaging::Message ^ Peek();

public System.Messaging.Message Peek ();

member this.Peek : unit -> System.Messaging.Message

Public Function Peek () As Message

Zwraca

Message

Wartość Message reprezentująca pierwszy komunikat w kolejce.

Wyjątki

MessageQueueException

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

Przykłady

W poniższych przykładach użyto Peek metody w kolejce.

W pierwszym przykładzie aplikacja czeka, aż komunikat stanie się dostępny w kolejce. Należy pamiętać, że pierwszy przykład nie uzyskuje dostępu do komunikatu, który jest dostarczany; wstrzymuje przetwarzanie tylko do momentu odebrania komunikatu. Jeśli komunikat już istnieje w kolejce, zostanie zwrócony natychmiast.

W drugim przykładzie do kolejki jest wysyłany komunikat zawierający klasę zdefiniowaną przez Order aplikację, a następnie podgląd z kolejki.

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

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// sends to a queue and receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Posts a notification when a message arrives in 
   // the queue S"monitoredQueue". Does not retrieve any 
   // message information when peeking the message.
   //*************************************************
   void NotifyArrived()
   {
      // Connect to a queue.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\monitoredQueue" );

      // Specify to retrieve no message information.
      myQueue->MessageReadPropertyFilter->ClearAll();

      // Wait for a message to arrive. 
      Message^ emptyMessage = myQueue->Peek();

      // Post a notification when a message arrives.
      Console::WriteLine( "A message has arrived in the queue." );
      return;
   }


   //*************************************************
   // Sends an Order to a queue.
   //*************************************************
   void SendMessage()
   {
      // Create a new order and set values.
      Order^ sentOrder = gcnew Order;
      sentOrder->orderId = 3;
      sentOrder->orderTime = DateTime::Now;

      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Send the Order to the queue.
      myQueue->Send( sentOrder );
      return;
   }

   //*************************************************
   // Peeks a message containing an Order.
   //*************************************************
   void PeekFirstMessage()
   {
      // Connect to a queue.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate the body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Peek and format the message. 
         Message^ myMessage = myQueue->Peek();
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example posts a notification that a message
// has arrived in a queue. It sends a message 
// containing an other to a separate queue, and then
// peeks the first message in the queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Wait for a message to arrive in the queue.
   myNewQueue->NotifyArrived();

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Peek the first message in the queue.
   myNewQueue->PeekFirstMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    // This class represents an object the following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example posts a notification that a message
        // has arrived in a queue. It sends a message
        // containing an other to a separate queue, and then
        // peeks the first message in the queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Wait for a message to arrive in the queue.
            myNewQueue.NotifyArrived();

            // Send a message to a queue.
            myNewQueue.SendMessage();	

            // Peek the first message in the queue.
            myNewQueue.PeekFirstMessage();
                        
            return;
        }

        //**************************************************
        // Posts a notification when a message arrives in
        // the queue "monitoredQueue". Does not retrieve any
        // message information when peeking the message.
        //**************************************************
        
        public void NotifyArrived()
        {

            // Connect to a queue.
            MessageQueue myQueue = new
                MessageQueue(".\\monitoredQueue");
    
            // Specify to retrieve no message information.
            myQueue.MessageReadPropertyFilter.ClearAll();

            // Wait for a message to arrive.
            Message emptyMessage = myQueue.Peek();

            // Post a notification when a message arrives.
            Console.WriteLine("A message has arrived in the queue.");

            return;
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            
            // Create a new order and set values.
            Order sentOrder = new Order();
            sentOrder.orderId = 3;
            sentOrder.orderTime = DateTime.Now;

            // Connect to a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            return;
        }

        //**************************************************
        // Peeks a message containing an Order.
        //**************************************************
        
        public void PeekFirstMessage()
        {
            // Connect to a queue.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
    
            // Set the formatter to indicate the body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Peek and format the message.
                Message myMessage =	myQueue.Peek();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging



    ' This class represents an object the following example 
    ' sends to a queue and peeks from a queue.
    Public Class Order
        Public orderId As Integer
        Public orderTime As DateTime
    End Class


   
    Public Class MyNewQueue


        
        ' Provides an entry point into the application.
        '		 
        ' This example posts a notification that a message
        ' has arrived in a queue. It sends a message 
        ' containing an other to a separate queue, and then
        ' peeks the first message in the queue.
        

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Wait for a message to arrive in the queue.
            myNewQueue.NotifyArrived()

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Peek the first message in the queue.
            myNewQueue.PeekFirstMessage()

            Return

        End Sub


        
        ' Posts a notification when a message arrives in 
        ' the queue "monitoredQueue". Does not retrieve any 
        ' message information when peeking the message.
        
        Public Sub NotifyArrived()

            ' Connect to a queue.
            Dim myQueue As New MessageQueue(".\monitoredQueue")

            ' Specify to retrieve no message information.
            myQueue.MessageReadPropertyFilter.ClearAll()

            ' Wait for a message to arrive. 
            Dim emptyMessage As Message = myQueue.Peek()

            ' Post a notification when a message arrives.
            Console.WriteLine("A message has arrived in the queue.")

            Return

        End Sub


        
        ' Sends an Order to a queue.
        

        Public Sub SendMessage()

            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Send the Order to the queue.
            myQueue.Send(sentOrder)

            Return

        End Sub


        
        ' Peeks a message containing an Order.
        

        Public Sub PeekFirstMessage()

            ' Connect to a queue.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Peek and format the message. 
                Dim myMessage As Message = myQueue.Peek()
                Dim myOrder As Order = CType(myMessage.Body, Order)

                ' Display message information.
                Console.WriteLine(("Order ID: " + _
                    myOrder.orderId.ToString()))
                Console.WriteLine(("Sent: " + _
                    myOrder.orderTime.ToString()))

            Catch m as MessageQueueException
                ' Handle Message Queuing exceptions.


            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)

                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Uwagi

Użyj tego przeciążenia, aby zajrzeć do kolejki lub zaczekać, aż komunikat istnieje w kolejce.

Metoda Peek odczytuje, ale nie usuwa pierwszego komunikatu z kolejki. W związku z tym powtarzające się wywołania w celu Peek zwrócenia tego samego komunikatu, chyba że w kolejce pojawi się komunikat o wyższym priorycie. Z Receive drugiej strony metoda odczytuje i usuwa pierwszy komunikat z kolejki. W związku z tym powtarzające się wywołania funkcji Receivezwracają różne komunikaty.

Kolejkowanie komunikatów porządkuje komunikaty w kolejce zgodnie z priorytetem i czasem przybycia. Nowszy komunikat jest umieszczany przed starszym tylko wtedy, gdy ma wyższy priorytet.

Użyj Peek polecenia , gdy bieżący wątek jest akceptowalny, aby był blokowany podczas oczekiwania na nadejście komunikatu do kolejki. Ponieważ to przeciążenie nie określa limitu czasu, aplikacja może czekać na czas nieokreślony. Jeśli potrzebujesz przetwarzania aplikacji, aby kontynuować bez oczekiwania, użyj metody asynchronicznej BeginPeek . Alternatywnie możesz określić limit czasu dla komunikatu, który ma pojawić się w kolejce, używając przeciążenia Peek , które określa limit czasu.

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

Peek(TimeSpan)

public:
 System::Messaging::Message ^ Peek(TimeSpan timeout);

public System.Messaging.Message Peek (TimeSpan timeout);

member this.Peek : TimeSpan -> System.Messaging.Message

Public Function Peek (timeout As TimeSpan) As Message

Parametry

timeout: TimeSpan

Element TimeSpan wskazujący maksymalny czas oczekiwania na kolejkę zawierającą komunikat.

Zwraca

Message

Wartość Message reprezentująca pierwszy komunikat w kolejce.

Wyjątki

ArgumentException

Wartość określona dla parametru timeout jest nieprawidłowa, prawdopodobnie timeout jest mniejsza lub większa niż Zero InfiniteTimeout.

MessageQueueException

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

Przykłady

W poniższym przykładzie kodu użyto Peek metody z limitem czasu 0, aby sprawdzić, czy kolejka jest pusta.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

   //*************************************************
   // Determines whether a queue is empty. The Peek()
   // method throws an exception if there is no message
   // in the queue. This method handles that exception 
   // by returning true to the calling method.
   //*************************************************
   bool IsQueueEmpty()
   {
      bool isQueueEmpty = false;
      
      // Connect to a queue.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      try
      {
         
         // Set Peek to return immediately.
         myQueue->Peek( TimeSpan(0) );
         
         // If an IOTime->Item[Out] was* not thrown, there is a message 
         // in the queue.
         isQueueEmpty = false;
      }
      catch ( MessageQueueException^ e ) 
      {
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            
            // No message was in the queue.
            isQueueEmpty = true;
         }

         
         // Handle other sources of MessageQueueException.
      }

      
      // Handle other exceptions as necessary.
      // Return true if there are no messages in the queue.
      return isQueueEmpty;
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example determines whether a queue is empty.
//*************************************************
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Determine whether a queue is empty.
   bool isQueueEmpty = myNewQueue->IsQueueEmpty();
   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 determines whether a queue is empty.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Determine whether a queue is empty.
            bool isQueueEmpty = myNewQueue.IsQueueEmpty();
                        
            return;
        }

        //**************************************************
        // Determines whether a queue is empty. The Peek()
        // method throws an exception if there is no message
        // in the queue. This method handles that exception
        // by returning true to the calling method.
        //**************************************************
        
        public bool IsQueueEmpty()
        {
            bool isQueueEmpty = false;

            // Connect to a queue.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            try
            {
                // Set Peek to return immediately.
                myQueue.Peek(new TimeSpan(0));

                // If an IOTimeout was not thrown, there is a message
                // in the queue.
                isQueueEmpty = false;
            }

            catch(MessageQueueException e)
            {
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    // No message was in the queue.
                    isQueueEmpty = true;
                }

                // Handle other sources of MessageQueueException.
            }

            // Handle other exceptions as necessary.

            // Return true if there are no messages in the queue.
            return isQueueEmpty;
        }
    }
}

Imports System.Messaging



   
    Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example determines whether a queue is empty.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Determine whether a queue is empty.
            Dim IsQueueEmpty As Boolean = myNewQueue.IsQueueEmpty()
        if IsQueueEMpty=True Then Console.WriteLine("Empty")
            

            Return

        End Sub


        '
        ' Determines whether a queue is empty. The Peek()
        ' method throws an exception if there is no message
        ' in the queue. This method handles that exception 
        ' by returning true to the calling method.
        '

        Public Function IsQueueEmpty() As Boolean

            'Dim QueueEmpty As Boolean = False

            ' Connect to a queue.
            Dim myQueue As New MessageQueue(".\myQueue")

            Try

                ' Set Peek to return immediately.
                myQueue.Peek(New TimeSpan(0))

                ' If an IOTimeout was not thrown, there is a message 
                ' in the queue.
                'queueEmpty = False

            Catch e As MessageQueueException

                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    ' No message was in the queue.
                    IsQueueEmpty = True

                End If

                ' Handle other sources of MessageQueueException as necessary.

                ' Handle other exceptions as necessary.

            End Try

            ' Return true if there are no messages in the queue.
            'Return queueEmpty
        IsQueueEmpty = False

        End Function 'IsQueueEmpty 

End Class

Uwagi

Użyj tego przeciążenia, aby zajrzeć do kolejki lub zaczekać określony okres czasu, aż komunikat istnieje w kolejce. Metoda zwraca natychmiast, jeśli komunikat już istnieje w kolejce.

Kolejkowanie komunikatów porządkuje komunikaty w kolejce zgodnie z priorytetem i czasem przybycia. Nowszy komunikat jest umieszczany przed starszym tylko wtedy, gdy ma wyższy priorytet.

Użyj Peek polecenia , gdy bieżący wątek jest akceptowalny, aby był blokowany podczas oczekiwania na nadejście komunikatu do kolejki. Wątek zostanie zablokowany do określonego okresu lub na czas nieokreślony, jeśli wskazano InfiniteTimeoutwartość . Jeśli potrzebujesz przetwarzania aplikacji, aby kontynuować bez oczekiwania, użyj metody asynchronicznej BeginPeek .

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

Peek(TimeSpan, Cursor, PeekAction)

Zwraca wartość bez usuwania (wglądu) bieżącego lub następnego komunikatu w kolejce przy użyciu określonego kursora. Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu lub przekroczenia określonego limitu czasu.

public:
 System::Messaging::Message ^ Peek(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::PeekAction action);

public System.Messaging.Message Peek (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.PeekAction action);

member this.Peek : TimeSpan * System.Messaging.Cursor * System.Messaging.PeekAction -> System.Messaging.Message

Public Function Peek (timeout As TimeSpan, cursor As Cursor, action As PeekAction) As Message

Parametry

timeout: TimeSpan

Element TimeSpan wskazujący maksymalny czas oczekiwania na kolejkę zawierającą komunikat.

cursor: Cursor

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

action: PeekAction

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

Zwraca

Message

Element Message reprezentujący komunikat w kolejce.

Wyjątki

ArgumentOutOfRangeException

Dla parametru określono wartość inną action niż PeekAction.Current lub PeekAction.Next .

ArgumentNullException

Parametr cursor ma wartość null.

ArgumentException

Wartość określona dla parametru timeout jest nieprawidłowa. Prawdopodobnie timeout wartość jest mniejsza lub większa niż InfiniteTimeout Zero .

MessageQueueException

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

Uwagi

Użyj tego przeciążenia, aby zajrzeć do kolejki lub zaczekać określony okres czasu, aż komunikat istnieje w kolejce. Metoda zwraca natychmiast, jeśli komunikat już istnieje w kolejce.

Metoda Peek odczytuje, ale nie usuwa komunikatu z kolejki. Z Receive drugiej strony metoda odczytuje i usuwa komunikat z kolejki.

Użyj Peek polecenia , gdy bieżący wątek jest akceptowalny, aby był blokowany podczas oczekiwania na nadejście komunikatu do kolejki. Wątek jest blokowany do określonego okresu lub na czas nieokreślony, jeśli wskazano InfiniteTimeoutwartość . Jeśli potrzebujesz przetwarzania aplikacji, aby kontynuować bez oczekiwania, użyj metody asynchronicznej BeginPeek .

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.

MessageQueue.Peek Metoda

Definicja

Przeciążenia

Peek()

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Peek(TimeSpan)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Peek(TimeSpan, Cursor, PeekAction)

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

Bezpieczeństwo wątkowe

Opinia

Dodatkowe zasoby