MessageQueue.Peek Yöntem

  • Başvuru

Tanım

Ad Alanı:
System.Messaging
Bütünleştirilmiş Kod:
System.Messaging.dll

kuyruktaki ilk iletinin bir kopyasını, iletiyi kuyruktan kaldırmadan döndürür.

Aşırı Yüklemeler

Peek()

Bu MessageQueuetarafından başvuruda bulunan kuyruktaki ilk iletiyi kaldırmadan (özetler) döndürür. Peek() yöntemi zaman uyumlu olduğundan, bir ileti kullanılabilir duruma gelene kadar geçerli iş parçacığını engeller.
Peek(TimeSpan)

Bu MessageQueuetarafından başvuruda bulunan kuyruktaki ilk iletiyi kaldırmadan (özetler) döndürür. Peek() yöntemi zaman uyumlu olduğundan, bir ileti kullanılabilir duruma gelene veya belirtilen zaman aşımı gerçekleşene kadar geçerli iş parçacığını engeller.
Peek(TimeSpan, Cursor, PeekAction)

Belirtilen imleci kullanarak kuyruktaki geçerli veya sonraki iletiyi kaldırmadan (göz atmadan) döndürür. Peek() yöntemi zaman uyumlu olduğundan, bir ileti kullanılabilir duruma gelene veya belirtilen zaman aşımı gerçekleşene kadar geçerli iş parçacığını engeller.

Peek()

Bu MessageQueuetarafından başvuruda bulunan kuyruktaki ilk iletiyi kaldırmadan (özetler) döndürür. Peek() yöntemi zaman uyumlu olduğundan, bir ileti kullanılabilir duruma gelene kadar geçerli iş parçacığını engeller.

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

Döndürülenler

Message

Kuyruktaki Message ilk iletiyi temsil eden.

Özel durumlar

MessageQueueException

Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki örneklerde kuyrukta Peek yöntemi kullanılır.

İlk örnekte, uygulama kuyrukta bir ileti kullanılabilir duruma gelene kadar bekler. İlk örneğin gelen iletiye erişmediğini unutmayın; yalnızca bir ileti gelene kadar işlemeyi duraklatır. Kuyrukta zaten bir ileti varsa, hemen döndürülecektir.

İkinci örnekte, uygulama tanımlı Order sınıfı içeren bir ileti kuyruğa gönderilir ve ardından kuyruktan göz atılır.

#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

Açıklamalar

Kuyruğa göz atmak veya kuyrukta bir ileti var olana kadar beklemek için bu aşırı yüklemeyi kullanın.

Peek yöntemi, kuyruktan ilk iletiyi okur ancak kaldırmaz. Bu nedenle, kuyruğa daha yüksek öncelikli bir ileti gelmediği sürece aynı iletiyi döndürmek için Peek yinelenen çağrılar. Receive Yöntemi ise kuyruktan ilk iletiyi okur ve kaldırır. Bu nedenle, öğesine Receiveyapılan yinelenen çağrılar farklı iletiler döndürür.

Message Queuing, kuyruktaki iletileri önceliğe ve varış zamanına göre sıralar. Daha yeni bir ileti, yalnızca daha yüksek öncelikliyse eski bir iletinin önüne yerleştirilir.

Bir iletinin kuyruğa gelmesini beklerken geçerli iş parçacığının engellenmesi kabul edilebilir olduğunda kullanın Peek . Bu aşırı yükleme bir zaman aşımı belirtmediğinden, uygulama süresiz olarak bekleyebilir. Uygulama işleminin beklemeden devam etmesi gerekiyorsa zaman uyumsuz BeginPeek yöntemini kullanın. Alternatif olarak, zaman aşımını belirten aşırı yüklemesini Peek kullanarak iletinin kuyruğa ulaşması için bir zaman aşımı belirtebilirsiniz.

Aşağıdaki tabloda bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu Kullanılabilir
Yerel bilgisayar Yes
Yerel bilgisayar ve doğrudan biçim adı Yes
Uzak bilgisayar No
Uzak bilgisayar ve doğrudan biçim adı Yes

Ayrıca bkz.

Şunlara uygulanır

Peek(TimeSpan)

Bu MessageQueuetarafından başvuruda bulunan kuyruktaki ilk iletiyi kaldırmadan (özetler) döndürür. Peek() yöntemi zaman uyumlu olduğundan, bir ileti kullanılabilir duruma gelene veya belirtilen zaman aşımı gerçekleşene kadar geçerli iş parçacığını engeller.

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

Parametreler

timeout
TimeSpan

Kuyruğun TimeSpan ileti içermesi için bekleyebilecek en uzun süreyi belirten bir.

Döndürülenler

Message

Kuyruktaki Message ilk iletiyi temsil eden.

Özel durumlar

ArgumentException

parametresi için timeout belirtilen değer geçerli değil, büyük olasılıkla timeout değerinden Zero küçük veya büyüktür InfiniteTimeout.

MessageQueueException

Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneği, kuyruğun Peek boş olup olmadığını denetlemek için sıfır zaman aşımı ile yöntemini kullanır.

#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

Açıklamalar

Kuyruğa göz atmak veya kuyrukta bir ileti var olana kadar belirli bir süre beklemek için bu aşırı yüklemeyi kullanın. Kuyrukta zaten bir ileti varsa yöntemi hemen döndürür.

Peek yöntemi, kuyruktan ilk iletiyi okur ancak kaldırmaz. Bu nedenle, kuyruğa daha yüksek öncelikli bir ileti gelmediği sürece aynı iletiyi döndürmek için Peek yinelenen çağrılar. Receive Yöntemi ise kuyruktan ilk iletiyi okur ve kaldırır. Bu nedenle, öğesine Receiveyapılan yinelenen çağrılar farklı iletiler döndürür.

Message Queuing, kuyruktaki iletileri önceliğe ve varış zamanına göre sıralar. Daha yeni bir ileti, yalnızca daha yüksek öncelikliyse eski bir iletinin önüne yerleştirilir.

Bir iletinin kuyruğa gelmesini beklerken geçerli iş parçacığının engellenmesi kabul edilebilir olduğunda kullanın Peek . İş parçacığı belirtilen süreye kadar veya belirttiyseniz InfiniteTimeoutsüresiz olarak engellenir. Uygulama işleminin beklemeden devam etmesi gerekiyorsa zaman uyumsuz BeginPeek yöntemini kullanın.

Aşağıdaki tabloda bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu Kullanılabilir
Yerel bilgisayar Yes
Yerel bilgisayar ve doğrudan biçim adı Yes
Uzak bilgisayar No
Uzak bilgisayar ve doğrudan biçim adı Yes

Ayrıca bkz.

Şunlara uygulanır

Peek(TimeSpan, Cursor, PeekAction)

Belirtilen imleci kullanarak kuyruktaki geçerli veya sonraki iletiyi kaldırmadan (göz atmadan) döndürür. Peek() yöntemi zaman uyumlu olduğundan, bir ileti kullanılabilir duruma gelene veya belirtilen zaman aşımı gerçekleşene kadar geçerli iş parçacığını engeller.

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

Parametreler

timeout
TimeSpan

Kuyruğun TimeSpan ileti içermesi için bekleyebilecek en uzun süreyi belirten bir.

cursor
Cursor

Cursor İleti kuyruğunda belirli bir konumu koruyan.

action
PeekAction

Değerlerden PeekAction biri. Kuyruktaki geçerli iletiye mi yoksa sonraki iletiye mi göz atılmayacağını gösterir.

Döndürülenler

Message

Message Kuyruktaki bir iletiyi temsil eden bir.

Özel durumlar

ArgumentOutOfRangeException

parametresi için action veya PeekAction.Next dışında PeekAction.Current bir değer belirtildi.

ArgumentNullException

cursor parametresidirnull.

ArgumentException

parametresi için timeout belirtilen değer geçerli değil. Büyük olasılıkla timeout değerinden Zero küçük veya büyüktür InfiniteTimeout.

MessageQueueException

Message Queuing yöntemine erişilirken bir hata oluştu.

Açıklamalar

Kuyruğa göz atmak veya kuyrukta bir ileti var olana kadar belirli bir süre beklemek için bu aşırı yüklemeyi kullanın. Kuyrukta zaten bir ileti varsa yöntemi hemen döndürür.

Peek yöntemi, kuyruktan bir iletiyi okur ancak kaldırmaz. Receive Öte yandan yöntemi, bir iletiyi kuyruktan okur ve kaldırır.

Bir iletinin kuyruğa gelmesini beklerken geçerli iş parçacığının engellenmesi kabul edilebilir olduğunda kullanın Peek . İş parçacığı belirtilen süreye kadar veya belirttiyseniz InfiniteTimeoutsüresiz olarak engellenir. Uygulama işleminin beklemeden devam etmesi gerekiyorsa zaman uyumsuz BeginPeek yöntemini kullanın.

Aşağıdaki tabloda bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu Kullanılabilir
Yerel bilgisayar Yes
Yerel bilgisayar ve doğrudan biçim adı Yes
Uzak bilgisayar No
Uzak bilgisayar ve doğrudan biçim adı Yes

Ayrıca bkz.

Şunlara uygulanır

İş Parçacığı Güvenliği

yöntemi iş parçacığı güvenli değil.