Comparteix a través de


MessageQueue.Peek Método

Definición

Devuelve una copia del primer mensaje de la cola, sin quitarlo de esta.

Sobrecargas

Peek()

Devuelve sin quitar (búsqueda peek) el primer mensaje de la cola a la que hace referencia esta MessageQueue. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible.

Peek(TimeSpan)

Devuelve sin quitar (búsqueda peek) el primer mensaje de la cola a la que hace referencia esta MessageQueue. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible o hasta que finalice el tiempo de espera especificado.

Peek(TimeSpan, Cursor, PeekAction)

Vuelve sin quitar (búsquedas peek) el mensaje actual o próximo de la cola, utilizando el cursor especificado. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible o hasta que finalice el tiempo de espera especificado.

Peek()

Devuelve sin quitar (búsqueda peek) el primer mensaje de la cola a la que hace referencia esta MessageQueue. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible.

public:
 System::Messaging::Message ^ Peek();
public System.Messaging.Message Peek ();
member this.Peek : unit -> System.Messaging.Message
Public Function Peek () As Message

Devoluciones

Message que representa al primer mensaje de la cola.

Excepciones

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En los ejemplos siguientes se usa el Peek método en una cola.

En el primer ejemplo, la aplicación espera hasta que un mensaje esté disponible en la cola. Tenga en cuenta que el primer ejemplo no tiene acceso al mensaje que llega; simplemente pausa el procesamiento hasta que llega un mensaje. Si ya existe un mensaje en la cola, devolverá inmediatamente.

En el segundo ejemplo, se envía un mensaje que contiene una clase definida por Order la aplicación a la cola y, a continuación, se muestra desde la cola.

#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

Comentarios

Use esta sobrecarga para ver una cola o esperar hasta que exista un mensaje en la cola.

El Peek método lee, pero no quita, el primer mensaje de la cola. Por lo tanto, las llamadas repetidas para devolver el mismo mensaje, a Peek menos que llegue un mensaje de prioridad más alta en la cola. Por Receive otro lado, el método lee y quita el primer mensaje de la cola. Las llamadas repetidas a Receive, por lo tanto, devuelven mensajes diferentes.

Message Queuing ordena mensajes en la cola según la prioridad y la hora de llegada. Un mensaje más reciente se coloca antes de uno anterior solo si es de mayor prioridad.

Utilice Peek cuando se acepte bloquear el subproceso actual mientras se espera a que llegue un mensaje a la cola. Dado que esta sobrecarga no especifica un tiempo de espera, la aplicación puede esperar indefinidamente. Si es necesario que la aplicación siga realizando sus procesos sin esperar, hay que utilizar el método asincrónico BeginPeek. Como alternativa, puede especificar un tiempo de espera para que un mensaje llegue a la cola mediante la sobrecarga de que especifica un tiempo de Peek espera.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local
Equipo local y nombre de formato directo
Equipo remoto No
Equipo remoto y nombre de formato directo

Consulte también

Se aplica a

Peek(TimeSpan)

Devuelve sin quitar (búsqueda peek) el primer mensaje de la cola a la que hace referencia esta MessageQueue. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible o hasta que finalice el tiempo de espera especificado.

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

Parámetros

timeout
TimeSpan

TimeSpan que indica el tiempo máximo que hay que esperar hasta que la cola contenga un mensaje.

Devoluciones

Message que representa al primer mensaje de la cola.

Excepciones

El valor que especifica el parámetro timeout no es válido, quizás porque timeout es menor que Zero o mayor que InfiniteTimeout.

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En el ejemplo de código siguiente se usa el Peek método con un tiempo de espera de cero para comprobar si la cola está vacía.

#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

Comentarios

Use esta sobrecarga para ver una cola o para esperar un período de tiempo especificado hasta que exista un mensaje en la cola. El método devuelve inmediatamente si ya existe un mensaje en la cola.

El Peek método lee, pero no quita, el primer mensaje de la cola. Por lo tanto, las llamadas repetidas para devolver el mismo mensaje, a Peek menos que llegue un mensaje de prioridad más alta en la cola. Por Receive otro lado, el método lee y quita el primer mensaje de la cola. Las llamadas repetidas a Receive, por lo tanto, devuelven mensajes diferentes.

Message Queuing ordena mensajes en la cola según la prioridad y la hora de llegada. Un mensaje más reciente se coloca antes de uno anterior solo si es de mayor prioridad.

Utilice Peek cuando se acepte bloquear el subproceso actual mientras se espera a que llegue un mensaje a la cola. El subproceso se bloqueará hasta el período de tiempo especificado o indefinidamente si indicó InfiniteTimeout. Si es necesario que la aplicación siga realizando sus procesos sin esperar, hay que utilizar el método asincrónico BeginPeek.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local
Equipo local y nombre de formato directo
Equipo remoto No
Equipo remoto y nombre de formato directo

Consulte también

Se aplica a

Peek(TimeSpan, Cursor, PeekAction)

Vuelve sin quitar (búsquedas peek) el mensaje actual o próximo de la cola, utilizando el cursor especificado. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible o hasta que finalice el tiempo de espera especificado.

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

Parámetros

timeout
TimeSpan

TimeSpan que indica el tiempo máximo que hay que esperar hasta que la cola contenga un mensaje.

cursor
Cursor

Un objeto Cursor que mantiene una posición específica en la cola de mensajes.

action
PeekAction

Uno de los valores de PeekAction. Indica si se ejecuta el método peek en el mensaje actual de la cola o en el mensaje siguiente.

Devoluciones

Una clase Message que representa un mensaje de la cola.

Excepciones

Se especificó un valor distinto de PeekAction.Current o PeekAction.Next para el parámetro action.

El parámetro cursor es null.

El valor especificado para el parámetro timeout no es válido. Probablemente timeout es menor que Zero o mayor que InfiniteTimeout.

Error al obtener acceso a un método de Message Queuing.

Comentarios

Use esta sobrecarga para ver una cola o para esperar un período de tiempo especificado hasta que exista un mensaje en la cola. El método devuelve inmediatamente si ya existe un mensaje en la cola.

El Peek método lee, pero no quita, un mensaje de la cola. Por Receive otro lado, el método lee y quita un mensaje de la cola.

Utilice Peek cuando se acepte bloquear el subproceso actual mientras se espera a que llegue un mensaje a la cola. El subproceso se bloquea hasta el período de tiempo especificado o indefinidamente si ha indicado InfiniteTimeout. Si es necesario que la aplicación siga realizando sus procesos sin esperar, hay que utilizar el método asincrónico BeginPeek.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo Disponible
Equipo local
Equipo local y nombre de formato directo
Equipo remoto No
Equipo remoto y nombre de formato directo

Consulte también

Se aplica a

Seguridad para subprocesos

El método no es seguro para subprocesos.