Partager via


MessageQueue.Peek Méthode

Définition

Retourne une copie du premier message dans la file d'attente, sans supprimer le message de la file.

Surcharges

Peek()

Retourne (lit) le premier message figurant dans la file d'attente référencée par ce MessageQueue sans le supprimer. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible.

Peek(TimeSpan)

Retourne (lit) le premier message figurant dans la file d'attente référencée par ce MessageQueue sans le supprimer. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible ou que le délai spécifié expire.

Peek(TimeSpan, Cursor, PeekAction)

Retourne (lit) le message actuel ou le message suivant de la file d'attente sans le supprimer, à l'aide du curseur spécifié. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible ou que le délai spécifié expire.

Peek()

Retourne (lit) le premier message figurant dans la file d'attente référencée par ce MessageQueue sans le supprimer. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible.

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

Retours

Message représentant le premier message dans la file d'attente.

Exceptions

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

Les exemples suivants utilisent la Peek méthode sur une file d’attente.

Dans le premier exemple, l’application attend qu’un message soit disponible dans la file d’attente. Notez que le premier exemple n’accède pas au message qui arrive ; il interrompt simplement le traitement jusqu’à ce qu’un message arrive. Si un message existe déjà dans la file d’attente, il retourne immédiatement.

Dans le deuxième exemple, un message qui contient une classe définie par Order l’application est envoyé à la file d’attente, puis aperçu à partir de la file d’attente.

#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

Remarques

Utilisez cette surcharge pour jeter un coup d’œil à une file d’attente ou pour attendre qu’un message existe dans la file d’attente.

La Peek méthode lit, mais ne supprime pas, le premier message de la file d’attente. Par conséquent, les appels répétés pour Peek retourner le même message, sauf si un message de priorité plus élevée arrive dans la file d’attente. La Receive méthode, d’autre part, lit et supprime le premier message de la file d’attente. Les appels répétés à Receive, par conséquent, retournent différents messages.

Message Queuing classe les messages dans la file d’attente en fonction de la priorité et de l’heure d’arrivée. Un message plus récent n’est placé devant un message plus ancien que s’il est d’une priorité plus élevée.

Utilisez Peek lorsque le thread en cours peut faire l'objet d'un blocage en attendant l'arrivée d'un message dans la file d'attente. Étant donné que cette surcharge ne spécifie pas de délai d’attente, l’application peut attendre indéfiniment. Si vous souhaitez que le traitement de l'application se poursuive sans attendre, utilisez la méthode BeginPeek asynchrone. Vous pouvez également spécifier un délai d’attente pour qu’un message arrive dans la file d’attente en utilisant la surcharge de Peek qui spécifie un délai d’attente.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail Disponible
Ordinateur local Oui
Ordinateur local et nom de format direct Oui
Ordinateur distant Non
Ordinateur distant et nom de format direct Oui

Voir aussi

S’applique à

Peek(TimeSpan)

Retourne (lit) le premier message figurant dans la file d'attente référencée par ce MessageQueue sans le supprimer. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible ou que le délai spécifié expire.

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

Paramètres

timeout
TimeSpan

TimeSpan qui indique le délai maximal à attendre pour l'arrivée d'un message dans la file d'attente.

Retours

Message représentant le premier message dans la file d'attente.

Exceptions

La valeur spécifiée pour le paramètre timeout n'est pas valide. Il se peut que timeout soit inférieur à Zero ou supérieur à InfiniteTimeout.

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant utilise la Peek méthode avec un délai d’expiration de zéro pour case activée si la file d’attente est vide.

#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

Remarques

Utilisez cette surcharge pour jeter un coup d’œil à une file d’attente ou pour attendre une période spécifiée jusqu’à ce qu’un message existe dans la file d’attente. La méthode retourne immédiatement si un message existe déjà dans la file d’attente.

La Peek méthode lit, mais ne supprime pas, le premier message de la file d’attente. Par conséquent, les appels répétés pour Peek retourner le même message, sauf si un message de priorité plus élevée arrive dans la file d’attente. La Receive méthode, d’autre part, lit et supprime le premier message de la file d’attente. Les appels répétés à Receive, par conséquent, retournent différents messages.

Message Queuing classe les messages dans la file d’attente en fonction de la priorité et de l’heure d’arrivée. Un message plus récent n’est placé devant un message plus ancien que s’il est d’une priorité plus élevée.

Utilisez Peek lorsque le thread en cours peut faire l'objet d'un blocage en attendant l'arrivée d'un message dans la file d'attente. Le thread sera bloqué jusqu’à la période spécifiée, ou indéfiniment si vous avez indiqué InfiniteTimeout. Si vous souhaitez que le traitement de l'application se poursuive sans attendre, utilisez la méthode BeginPeek asynchrone.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail Disponible
Ordinateur local Oui
Ordinateur local et nom de format direct Oui
Ordinateur distant Non
Ordinateur distant et nom de format direct Oui

Voir aussi

S’applique à

Peek(TimeSpan, Cursor, PeekAction)

Retourne (lit) le message actuel ou le message suivant de la file d'attente sans le supprimer, à l'aide du curseur spécifié. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible ou que le délai spécifié expire.

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

Paramètres

timeout
TimeSpan

TimeSpan qui indique le délai maximal à attendre pour l'arrivée d'un message dans la file d'attente.

cursor
Cursor

Cursor qui conserve une position spécifique dans la file d'attente de messages.

action
PeekAction

Une des valeurs de l'objet PeekAction. Indique s'il faut lire le message en cours dans la file d'attente ou le message suivant.

Retours

Message qui représente un message dans la file d'attente.

Exceptions

Une valeur autre que PeekAction.Current ou PeekAction.Next a été spécifiée pour le paramètre action.

Le paramètre cursor a la valeur null.

La valeur spécifiée pour le paramètre timeout n'est pas valide. Il est possible que timeout soit inférieur à Zero ou supérieur à InfiniteTimeout.

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Remarques

Utilisez cette surcharge pour jeter un coup d’œil à une file d’attente ou pour attendre une période spécifiée jusqu’à ce qu’un message existe dans la file d’attente. La méthode retourne immédiatement si un message existe déjà dans la file d’attente.

La Peek méthode lit, mais ne supprime pas, un message de la file d’attente. La Receive méthode, d’autre part, lit et supprime un message de la file d’attente.

Utilisez Peek lorsque le thread en cours peut faire l'objet d'un blocage en attendant l'arrivée d'un message dans la file d'attente. Le thread est bloqué jusqu’à la période spécifiée, ou indéfiniment si vous avez indiqué InfiniteTimeout. Si vous souhaitez que le traitement de l'application se poursuive sans attendre, utilisez la méthode BeginPeek asynchrone.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail Disponible
Ordinateur local Oui
Ordinateur local et nom de format direct Oui
Ordinateur distant Non
Ordinateur distant et nom de format direct Oui

Voir aussi

S’applique à

Cohérence de thread

La méthode n’est pas thread safe.