Condividi tramite


MessageQueue.Peek Metodo

Definizione

Restituisce una copia del primo messaggio della coda senza rimuoverlo da quest'ultima.

Overload

Peek()

Termina senza rimuovere (legge) il primo messaggio nella coda a cui l'oggetto MessageQueue fa riferimento. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio.

Peek(TimeSpan)

Termina senza rimuovere (legge) il primo messaggio nella coda a cui l'oggetto MessageQueue fa riferimento. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio o non si verifica il timeout specificato.

Peek(TimeSpan, Cursor, PeekAction)

Termina senza rimuovere (legge) il messaggio corrente o successivo della coda, utilizzando il cursore specificato. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio o non si verifica il timeout specificato.

Peek()

Termina senza rimuovere (legge) il primo messaggio nella coda a cui l'oggetto MessageQueue fa riferimento. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio.

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

Restituisce

Message che rappresenta il primo messaggio della coda.

Eccezioni

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.

Esempio

Negli esempi seguenti viene usato il Peek metodo in una coda.

Nel primo esempio l'applicazione attende che un messaggio diventi disponibile nella coda. Si noti che il primo esempio non accede al messaggio che arriva; sospende semplicemente l'elaborazione fino all'arrivo di un messaggio. Se nella coda esiste già un messaggio, verrà restituito immediatamente.

Nel secondo esempio viene inviato un messaggio contenente una classe definita dall'applicazione Order alla coda e quindi visualizzato dalla coda.

#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

Commenti

Usare questo overload per visualizzare una coda o attendere l'esistenza di un messaggio nella coda.

Il Peek metodo legge, ma non rimuove, il primo messaggio dalla coda. Di conseguenza, le chiamate ripetute per Peek restituire lo stesso messaggio, a meno che non arrivi un messaggio con priorità più alta nella coda. Il Receive metodo, d'altra parte, legge e rimuove il primo messaggio dalla coda. Le chiamate ripetute a Receive, pertanto, restituiscono messaggi diversi.

Accodamento messaggi ordina i messaggi nella coda in base alla priorità e all'ora di arrivo. Un messaggio più recente viene inserito prima di un precedente solo se è di una priorità più alta.

Utilizzare il metodo Peek quando è possibile bloccare il thread corrente durante l'attesa dell'arrivo di un messaggio nella coda. Poiché questo overload non specifica un timeout, l'applicazione potrebbe attendere per un periodo illimitato. Se si desidera che l'elaborazione dell'applicazione continui senza attendere, utilizzare il metodo asincrono BeginPeek. In alternativa, è possibile specificare un timeout per l'arrivo di un messaggio nella coda usando l'overload di Peek che specifica un timeout.

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Modalità gruppo di lavoro Disponibile
Computer locale
Computer locale e nome del formato diretto
Computer remoto No
Nome del formato diretto e del computer remoto

Vedi anche

Si applica a

Peek(TimeSpan)

Termina senza rimuovere (legge) il primo messaggio nella coda a cui l'oggetto MessageQueue fa riferimento. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio o non si verifica il timeout specificato.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica il tempo massimo di attesa affinché un messaggio venga inserito nella coda.

Restituisce

Message che rappresenta il primo messaggio della coda.

Eccezioni

Il valore specificato per il parametro timeout non è valido, probabilmente perché timeout è minore di Zero o maggiore di InfiniteTimeout.

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.

Esempio

Nell'esempio di codice seguente viene usato il Peek metodo con un timeout pari a zero per verificare se la coda è vuota.

#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

Commenti

Usare questo overload per visualizzare una coda o attendere un periodo di tempo specificato fino a quando non esiste un messaggio nella coda. Il metodo restituisce immediatamente se nella coda esiste già un messaggio.

Il Peek metodo legge, ma non rimuove, il primo messaggio dalla coda. Di conseguenza, le chiamate ripetute per Peek restituire lo stesso messaggio, a meno che non arrivi un messaggio con priorità più alta nella coda. Il Receive metodo, d'altra parte, legge e rimuove il primo messaggio dalla coda. Le chiamate ripetute a Receive, pertanto, restituiscono messaggi diversi.

Accodamento messaggi ordina i messaggi nella coda in base alla priorità e all'ora di arrivo. Un messaggio più recente viene inserito prima di un precedente solo se è di una priorità più alta.

Utilizzare il metodo Peek quando è possibile bloccare il thread corrente durante l'attesa dell'arrivo di un messaggio nella coda. Il thread verrà bloccato fino al periodo di tempo specificato o a tempo indefinito se è stato indicato InfiniteTimeout. Se si desidera che l'elaborazione dell'applicazione continui senza attendere, utilizzare il metodo asincrono BeginPeek.

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Modalità gruppo di lavoro Disponibile
Computer locale
Computer locale e nome del formato diretto
Computer remoto No
Nome del formato diretto e del computer remoto

Vedi anche

Si applica a

Peek(TimeSpan, Cursor, PeekAction)

Termina senza rimuovere (legge) il messaggio corrente o successivo della coda, utilizzando il cursore specificato. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio o non si verifica il timeout specificato.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica il tempo massimo di attesa affinché un messaggio venga inserito nella coda.

cursor
Cursor

Oggetto Cursor che occupa una posizione specifica nella coda messaggi.

action
PeekAction

Uno dei valori di PeekAction. Indica se leggere il messaggio corrente nella coda oppure il messaggio successivo.

Restituisce

Oggetto Message che rappresenta un messaggio della coda.

Eccezioni

È stato specificato un valore diverso da PeekAction.Current o PeekAction.Next per il parametro action.

Il valore del parametro cursor è null.

Il valore specificato per il parametro timeout non è valido. Probabilmente timeout è minore di Zero o maggiore di InfiniteTimeout.

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.

Commenti

Usare questo overload per visualizzare una coda o attendere un periodo di tempo specificato fino a quando non esiste un messaggio nella coda. Il metodo restituisce immediatamente se nella coda esiste già un messaggio.

Il Peek metodo legge, ma non rimuove, un messaggio dalla coda. Il Receive metodo, d'altra parte, legge e rimuove un messaggio dalla coda.

Utilizzare il metodo Peek quando è possibile bloccare il thread corrente durante l'attesa dell'arrivo di un messaggio nella coda. Il thread viene bloccato fino al periodo di tempo specificato o per un periodo illimitato se è stato indicato InfiniteTimeout. Se si desidera che l'elaborazione dell'applicazione continui senza attendere, utilizzare il metodo asincrono BeginPeek.

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Modalità gruppo di lavoro Disponibile
Computer locale
Computer locale e nome del formato diretto
Computer remoto No
Nome del formato diretto e del computer remoto

Vedi anche

Si applica a

Thread safety

Il metodo non è thread-safe.