MessageQueue.Peek Metoda

Reference

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í.

Vrátí kopii první zprávy ve frontě bez odebrání zprávy z fronty.

Přetížení

Peek()	Vrátí bez odebrání (náhledy) první zprávu ve frontě, na kterou odkazuje .MessageQueue Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva.
Peek(TimeSpan)	Vrátí bez odebrání (náhledy) první zprávu ve frontě, na kterou odkazuje .MessageQueue Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva nebo dojde k zadanému vypršení časového limitu.
Peek(TimeSpan, Cursor, PeekAction)	Vrátí hodnotu bez odebrání (náhledu) aktuální nebo další zprávy ve frontě pomocí zadaného kurzoru. Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva nebo dojde k zadanému vypršení časového limitu.

Peek()

Vrátí bez odebrání (náhledy) první zprávu ve frontě, na kterou odkazuje .MessageQueue Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva.

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

public System.Messaging.Message Peek ();

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

Public Function Peek () As Message

Návraty

Message

Jedná se Message o první zprávu ve frontě.

Výjimky

MessageQueueException

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

Příklady

Následující příklady používají metodu ve Peek frontě.

V prvním příkladu aplikace počká na zpřístupnění zprávy ve frontě. Všimněte si, že první příklad nepřistupuje ke zprávě, která přijde; pouze pozastaví zpracování, dokud nedorazí zpráva. Pokud už zpráva ve frontě existuje, okamžitě se vrátí.

Ve druhém příkladu se do fronty odešle zpráva, která obsahuje třídu definovanou Order aplikací, a pak se z fronty zobrazí náhled.

#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

Poznámky

Toto přetížení slouží k zobrazení fronty nebo k čekání na existenci zprávy ve frontě.

Metoda Peek přečte, ale neodebere, první zprávu z fronty. Proto opakovaná volání vracející Peek stejnou zprávu, pokud do fronty nedorazí zpráva s vyšší prioritou. Metoda Receive na druhou stranu čte i odebere první zprávu z fronty. Opakovaná volání proto Receivevrací různé zprávy.

Řízení front zpráv objednává zprávy ve frontě podle priority a času doručení. Novější zpráva je umístěna před starší pouze v případě, že má vyšší prioritu.

Použijte Peek , pokud je přijatelné, aby aktuální vlákno bylo blokováno, zatímco čeká na doručení zprávy do fronty. Vzhledem k tomu, že toto přetížení neurčuje časový limit, může aplikace čekat neomezeně dlouho. Pokud potřebujete, aby zpracování aplikace pokračovalo bez čekání, použijte asynchronní BeginPeek metodu. Případně můžete určit časový limit pro doručení zprávy do fronty pomocí přetížení Peek , které určuje časový limit.

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

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

Viz také

Platí pro

Peek(TimeSpan)

Vrátí bez odebrání (náhledy) první zprávu ve frontě, na kterou odkazuje .MessageQueue Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva nebo dojde k zadanému vypršení časového limitu.

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

A TimeSpan označující maximální dobu čekání, než fronta bude obsahovat zprávu.

Návraty

Message

Jedná se Message o první zprávu ve frontě.

Výjimky

ArgumentException

Hodnota zadaná pro timeout parametr není platná, pravděpodobně timeout je menší než Zero nebo větší než InfiniteTimeout.

MessageQueueException

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

Příklady

Následující příklad kódu používá metodu Peek s nulovým časovým limitem ke kontrole, jestli je fronta prázdná.

#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

Poznámky

Toto přetížení slouží k zobrazení fronty nebo k čekání na určitou dobu, dokud ve frontě nebude existovat zpráva. Pokud již ve frontě existuje zpráva, vrátí metoda okamžitě.

Řízení front zpráv objednává zprávy ve frontě podle priority a času doručení. Novější zpráva je umístěna před starší pouze v případě, že má vyšší prioritu.

Použijte Peek , pokud je přijatelné, aby aktuální vlákno bylo blokováno, zatímco čeká na doručení zprávy do fronty. Vlákno bude blokováno až do zadaného časového období, nebo na neurčito, pokud jste uvedli InfiniteTimeout. Pokud potřebujete, aby zpracování aplikace pokračovalo bez čekání, použijte asynchronní BeginPeek metodu.

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

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

Viz také

Platí pro

Peek(TimeSpan, Cursor, PeekAction)

Vrátí hodnotu bez odebrání (náhledu) aktuální nebo další zprávy ve frontě pomocí zadaného kurzoru. Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva nebo dojde k zadanému vypršení časového limitu.

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

A TimeSpan označující maximální dobu čekání, než fronta bude obsahovat zprávu.

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 další zpráva.

Návraty

Message

A Message , která představuje zprávu ve frontě.

Výjimky

ArgumentOutOfRangeException

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

ArgumentNullException

Parametr cursor je null.

ArgumentException

Hodnota zadaná pro timeout parametr není platná. Možná timeout je menší než Zero nebo větší než InfiniteTimeout.

MessageQueueException

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

Poznámky

Toto přetížení slouží k zobrazení fronty nebo k čekání na určitou dobu, dokud ve frontě nebude existovat zpráva. Pokud již ve frontě existuje zpráva, vrátí metoda okamžitě.

Metoda Peek přečte, ale neodebere, zprávu z fronty. Metoda Receive naproti tomu čte zprávu a odebere ji z fronty.

Použijte Peek , pokud je přijatelné, aby aktuální vlákno bylo blokováno, zatímco čeká na doručení zprávy do fronty. Vlákno je blokováno až do zadaného časového období, nebo na neomezenou dobu, pokud jste uvedli InfiniteTimeout. Pokud potřebujete, aby zpracování aplikace pokračovalo bez čekání, použijte asynchronní BeginPeek metodu.

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

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

Viz také

Platí pro

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

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

Sdílet prostřednictvím

MessageQueue.Peek Metoda

Definice

Přetížení

Peek()

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Peek(TimeSpan)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Peek(TimeSpan, Cursor, PeekAction)

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

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

Další materiály