MessageQueue.Peek Método

Referência

Definição

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Retorna uma cópia da primeira mensagem na fila sem remover a mensagem da fila.

Sobrecargas

Peek()	Retorna sem remover (espia) a primeira mensagem na fila referenciada por este MessageQueue. O método Peek() é síncrono. Portanto, ele bloqueia o thread atual até que uma mensagem se torne disponível.
Peek(TimeSpan)	Retorna sem remover (espia) a primeira mensagem na fila referenciada por este MessageQueue. O método Peek() é síncrono e, portanto, bloqueia o thread atual até que uma mensagem fique disponível ou o tempo limite especificado seja atingido.
Peek(TimeSpan, Cursor, PeekAction)	Retorna sem remover (espia) a mensagem atual ou a próxima na fila usando o cursor especificado. O método Peek() é síncrono e, portanto, bloqueia o thread atual até que uma mensagem fique disponível ou o tempo limite especificado seja atingido.

Peek()

Retorna sem remover (espia) a primeira mensagem na fila referenciada por este MessageQueue. O método Peek() é síncrono. Portanto, ele bloqueia o thread atual até que uma mensagem se torne disponível.

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

public System.Messaging.Message Peek ();

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

Public Function Peek () As Message

Retornos

Message

O Message que representa a primeira mensagem na fila.

Exceções

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Exemplos

Os exemplos a seguir usam o Peek método em uma fila.

No primeiro exemplo, o aplicativo aguarda até que uma mensagem fique disponível na fila. Observe que o primeiro exemplo não acessa a mensagem que chega; ele apenas pausa o processamento até que uma mensagem chegue. Se já existir uma mensagem na fila, ela retornará imediatamente.

No segundo exemplo, uma mensagem que contém uma classe definida Order pelo aplicativo é enviada para a fila e espiada da fila.

#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

Comentários

Use essa sobrecarga para espiar uma fila ou aguardar até que uma mensagem exista na fila.

O Peek método lê, mas não remove, a primeira mensagem da fila. Portanto, chamadas repetidas para Peek retornar a mesma mensagem, a menos que uma mensagem de prioridade mais alta chegue na fila. O Receive método , por outro lado, lê e remove a primeira mensagem da fila. Chamadas repetidas para Receive, portanto, retornam mensagens diferentes.

Mensagem O enfileiramento de mensagens ordena mensagens na fila de acordo com a prioridade e a hora de chegada. Uma mensagem mais recente será colocada antes de uma mais antiga somente se for de uma prioridade mais alta.

Use Peek quando for aceitável que o thread atual seja bloqueado enquanto aguarda a chegada de uma mensagem na fila. Como essa sobrecarga não especifica um tempo limite, o aplicativo pode aguardar indefinidamente. Se você precisar que o processamento do aplicativo continue sem esperar, use o método assíncrono BeginPeek . Como alternativa, você pode especificar um tempo limite para uma mensagem chegar na fila usando a sobrecarga de Peek que especifica um tempo limite.

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

Peek(TimeSpan)

Retorna sem remover (espia) a primeira mensagem na fila referenciada por este MessageQueue. O método Peek() é síncrono e, portanto, bloqueia o thread atual até que uma mensagem fique disponível ou o tempo limite especificado seja atingido.

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

Um TimeSpan que indica o tempo máximo de espera para que a fila contenha uma mensagem.

Retornos

Message

O Message que representa a primeira mensagem na fila.

Exceções

ArgumentException

O valor especificado para o parâmetro timeout não é válido, possivelmente timeout é menor que Zero ou maior que InfiniteTimeout.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Exemplos

O exemplo de código a seguir usa o Peek método com um tempo limite de zero para marcar se a fila está vazia.

#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

Comentários

Use essa sobrecarga para espiar uma fila ou aguardar um período de tempo especificado até que exista uma mensagem na fila. O método retornará imediatamente se já existir uma mensagem na fila.

Use Peek quando for aceitável que o thread atual seja bloqueado enquanto aguarda a chegada de uma mensagem na fila. O thread será bloqueado até o período de tempo especificado ou indefinidamente se você indicou InfiniteTimeout. Se você precisar que o processamento do aplicativo continue sem esperar, use o método assíncrono BeginPeek .

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

Peek(TimeSpan, Cursor, PeekAction)

Retorna sem remover (espia) a mensagem atual ou a próxima na fila usando o cursor especificado. O método Peek() é síncrono e, portanto, bloqueia o thread atual até que uma mensagem fique disponível ou o tempo limite especificado seja atingido.

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

Um TimeSpan que indica o tempo máximo de espera para que a fila contenha uma mensagem.

cursor: Cursor

Um Cursor que mantém uma posição específica na fila de mensagens.

action: PeekAction

Um dos valores de PeekAction. Indica se a mensagem atual ou a próxima na fila de mensagens deve ser espiada.

Retornos

Message

O Message que representa uma mensagem na fila.

Exceções

ArgumentOutOfRangeException

Um valor diferente de PeekAction.Current ou PeekAction.Next foi especificado para o parâmetro action.

ArgumentNullException

O parâmetro cursor é null.

ArgumentException

O valor especificado para o parâmetro timeout não é válido. Provavelmente timeout é menor que Zero ou maior que InfiniteTimeout.

MessageQueueException

Erro ao acessar um método do serviço de Enfileiramento de Mensagens.

Comentários

Use essa sobrecarga para espiar uma fila ou aguardar um período de tempo especificado até que exista uma mensagem na fila. O método retornará imediatamente se já existir uma mensagem na fila.

O Peek método lê, mas não remove, uma mensagem da fila. O Receive método , por outro lado, lê e remove uma mensagem da fila.

Use Peek quando for aceitável que o thread atual seja bloqueado enquanto aguarda a chegada de uma mensagem na fila. O thread é bloqueado até o período de tempo especificado ou indefinidamente se você indicou InfiniteTimeout. Se você precisar que o processamento do aplicativo continue sem esperar, use o método assíncrono BeginPeek .

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Modo de grupo de trabalho	Disponível
Computador local	Yes
Nome do computador local e do formato direto	Yes
Computador remoto	Não
Computador remoto e nome de formato direto	Yes

Confira também

Aplica-se a

Acesso thread-safe

O método não é thread-safe.

Partilhar via

MessageQueue.Peek Método

Definição

Sobrecargas

Peek()

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Peek(TimeSpan)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Peek(TimeSpan, Cursor, PeekAction)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Acesso thread-safe

Recursos adicionais