MessageQueue.Peek Methode

Definition

Gibt eine Kopie der ersten Meldung in der Warteschlange zurück, ohne die Meldung aus der Warteschlange zu entfernen.

Überlädt

Peek()

Wird beendet, ohne die erste Meldung in der Warteschlange zu entfernen (einzusehen), auf die diese MessageQueue verweist. Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread bis zum Eingang einer Meldung.

Peek(TimeSpan)

Wird beendet, ohne die erste Meldung in der Warteschlange zu entfernen (einzusehen), auf die diese MessageQueue verweist. Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread, bis eine Meldung verfügbar wird oder der Timeout eintritt.

Peek(TimeSpan, Cursor, PeekAction)

Wird beendet, ohne die aktuelle oder die nächste Meldung mithilfe des angegebenen Cursors zu entfernen (einzusehen). Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread, bis eine Meldung verfügbar wird oder der Timeout eintritt.

Peek()

Wird beendet, ohne die erste Meldung in der Warteschlange zu entfernen (einzusehen), auf die diese MessageQueue verweist. Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread bis zum Eingang einer Meldung.

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

Gibt zurück

Die Message, die die erste Meldung in der Warteschlange darstellt.

Ausnahmen

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

In den folgenden Beispielen wird die Peek -Methode für eine Warteschlange verwendet.

Im ersten Beispiel wartet die Anwendung, bis eine Nachricht in der Warteschlange verfügbar wird. Beachten Sie, dass im ersten Beispiel nicht auf die empfangene Nachricht zugegriffen wird. Die Verarbeitung wird lediglich angehalten, bis eine Nachricht eingeht. Wenn eine Nachricht bereits in der Warteschlange vorhanden ist, wird sie sofort zurückgegeben.

Im zweiten Beispiel wird eine Nachricht, die eine anwendungsdefinierte Order Klasse enthält, an die Warteschlange gesendet und dann aus der Warteschlange eingesehen.

#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

Hinweise

Verwenden Sie diese Überladung, um eine Warteschlange einzusehen oder zu warten, bis eine Nachricht in der Warteschlange vorhanden ist.

Die Peek -Methode liest die erste Nachricht aus der Warteschlange, entfernt sie jedoch nicht. Daher werden wiederholte Aufrufe verwendet, um Peek dieselbe Nachricht zurückzugeben, es sei denn, eine Nachricht mit höherer Priorität wird in der Warteschlange eingetroffen. Die Receive -Methode hingegen liest und entfernt die erste Nachricht aus der Warteschlange. Wiederholte Aufrufe von Receivegeben daher unterschiedliche Nachrichten zurück.

Message Queuing ordnet Nachrichten in der Warteschlange gemäß Priorität und Ankunftszeit an. Eine neuere Nachricht wird nur vor einer älteren Nachricht platziert, wenn sie eine höhere Priorität hat.

Verwenden Sie Peek¸ wenn eine Blockade des aktuellen Threads bis zum Eingehen einer Nachricht in die Warteschlange akzeptabel ist. Da diese Überladung kein Timeout angibt, wartet die Anwendung möglicherweise unbegrenzt. Wenn die Anwendungsverarbeitung ohne Wartezeiten fortgesetzt werden soll, verwenden Sie die asynchrone BeginPeek-Methode. Alternativ können Sie ein Timeout für eine Nachricht angeben, die in der Warteschlange eingeht, indem Sie die Überladung von Peek verwenden, die ein Timeout angibt.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Peek(TimeSpan)

Wird beendet, ohne die erste Meldung in der Warteschlange zu entfernen (einzusehen), auf die diese MessageQueue verweist. Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread, bis eine Meldung verfügbar wird oder der Timeout eintritt.

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

Parameter

timeout
TimeSpan

Eine TimeSpan, die die maximale Zeitspanne angibt, für die auf den Eingang einer Meldung gewartet werden soll.

Gibt zurück

Die Message, die die erste Meldung in der Warteschlange darstellt.

Ausnahmen

Der für den timeout-Parameter angegebene Wert ist ungültig. Möglicherweise ist der timeout kleiner als Zero oder größer als der InfiniteTimeout.

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird die Peek -Methode mit einem Timeout von 0 (null) verwendet, um zu überprüfen, ob die Warteschlange leer ist.

#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

Hinweise

Verwenden Sie diese Überladung, um eine Warteschlange einzusehen oder einen bestimmten Zeitraum zu warten, bis eine Nachricht in der Warteschlange vorhanden ist. Die -Methode gibt sofort zurück, wenn eine Nachricht bereits in der Warteschlange vorhanden ist.

Die Peek -Methode liest die erste Nachricht aus der Warteschlange, entfernt sie jedoch nicht. Daher werden wiederholte Aufrufe verwendet, um Peek dieselbe Nachricht zurückzugeben, es sei denn, eine Nachricht mit höherer Priorität wird in der Warteschlange eingetroffen. Die Receive -Methode hingegen liest und entfernt die erste Nachricht aus der Warteschlange. Wiederholte Aufrufe von Receivegeben daher unterschiedliche Nachrichten zurück.

Message Queuing ordnet Nachrichten in der Warteschlange gemäß Priorität und Ankunftszeit an. Eine neuere Nachricht wird nur vor einer älteren Nachricht platziert, wenn sie eine höhere Priorität hat.

Verwenden Sie Peek¸ wenn eine Blockade des aktuellen Threads bis zum Eingehen einer Nachricht in die Warteschlange akzeptabel ist. Der Thread wird bis zum angegebenen Zeitraum oder auf unbestimmte Zeit blockiert, wenn Sie angegeben haben InfiniteTimeout. Wenn die Anwendungsverarbeitung ohne Wartezeiten fortgesetzt werden soll, verwenden Sie die asynchrone BeginPeek-Methode.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Peek(TimeSpan, Cursor, PeekAction)

Wird beendet, ohne die aktuelle oder die nächste Meldung mithilfe des angegebenen Cursors zu entfernen (einzusehen). Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread, bis eine Meldung verfügbar wird oder der Timeout eintritt.

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

Parameter

timeout
TimeSpan

Eine TimeSpan, die die maximale Zeitspanne angibt, für die auf den Eingang einer Meldung gewartet werden soll.

cursor
Cursor

Ein Cursor, der eine bestimmte Position in der Meldungswarteschlange beibehält.

action
PeekAction

Einer der PeekAction-Werte. Gibt an, ob die aktuelle oder die folgende Meldung in der Warteschlange eingesehen wird.

Gibt zurück

Eine Message, die eine Meldung in der Warteschlange darstellt.

Ausnahmen

Für den action-Parameter wurde ein anderer Wert als PeekAction.Current oder PeekAction.Next angegeben.

Der cursor-Parameter ist null.

Der für den timeout-Parameter angegebene Wert ist nicht gültig. Möglicherweise ist timeout kleiner als Zero oder größer als InfiniteTimeout.

Fehler beim Zugriff auf eine Message Queuing-Methode.

Hinweise

Verwenden Sie diese Überladung, um eine Warteschlange einzusehen oder einen bestimmten Zeitraum zu warten, bis eine Nachricht in der Warteschlange vorhanden ist. Die -Methode gibt sofort zurück, wenn eine Nachricht bereits in der Warteschlange vorhanden ist.

Die Peek -Methode liest eine Nachricht aus der Warteschlange, entfernt sie jedoch nicht. Die Receive -Methode hingegen liest und entfernt eine Nachricht aus der Warteschlange.

Verwenden Sie Peek¸ wenn eine Blockade des aktuellen Threads bis zum Eingehen einer Nachricht in die Warteschlange akzeptabel ist. Der Thread wird bis zum angegebenen Zeitraum oder auf unbestimmte Zeit blockiert, wenn Sie angegeben haben InfiniteTimeout. Wenn die Anwendungsverarbeitung ohne Wartezeiten fortgesetzt werden soll, verwenden Sie die asynchrone BeginPeek-Methode.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Threadsicherheit

Die -Methode ist nicht threadsicher.