Bagikan melalui

MessageQueue.Peek Metode

  • Referensi

Definisi

Ruang nama:
System.Messaging
Rakitan:
System.Messaging.dll

Mengembalikan salinan pesan pertama dalam antrean tanpa menghapus pesan dari antrean.

Overload

Peek()

Mengembalikan tanpa menghapus (mengintip) pesan pertama dalam antrean yang direferensikan oleh ini MessageQueue. Metode Peek() ini sinkron, sehingga memblokir utas saat ini hingga pesan tersedia.
Peek(TimeSpan)

Mengembalikan tanpa menghapus (mengintip) pesan pertama dalam antrean yang direferensikan oleh ini MessageQueue. Metode Peek() ini sinkron, sehingga memblokir utas saat ini hingga pesan tersedia atau waktu habis yang ditentukan terjadi.
Peek(TimeSpan, Cursor, PeekAction)

Mengembalikan tanpa menghapus (mengintip) pesan saat ini atau berikutnya dalam antrean, menggunakan kursor yang ditentukan. Metode Peek() ini sinkron, sehingga memblokir utas saat ini hingga pesan tersedia atau waktu habis yang ditentukan terjadi.

Peek()

Mengembalikan tanpa menghapus (mengintip) pesan pertama dalam antrean yang direferensikan oleh ini MessageQueue. Metode Peek() ini sinkron, sehingga memblokir utas saat ini hingga pesan tersedia.

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

Mengembalikan

Message

Message yang mewakili pesan pertama dalam antrean.

Pengecualian

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh berikut menggunakan Peek metode pada antrean.

Dalam contoh pertama, aplikasi menunggu hingga pesan tersedia dalam antrean. Perhatikan bahwa contoh pertama tidak mengakses pesan yang tiba; itu hanya menjeda pemrosesan sampai pesan tiba. Jika pesan sudah ada dalam antrean, pesan akan segera kembali.

Dalam contoh kedua, pesan yang berisi kelas yang ditentukan Order aplikasi dikirim ke antrean, lalu diintip dari antrean.

#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

Keterangan

Gunakan kelebihan beban ini untuk mengintip antrean, atau menunggu hingga pesan ada dalam antrean.

Metode Peek membaca, tetapi tidak menghapus, pesan pertama dari antrean. Oleh karena itu, panggilan berulang untuk Peek mengembalikan pesan yang sama, kecuali pesan prioritas yang lebih tinggi tiba dalam antrean. Metode ini Receive , di sisi lain, membaca dan menghapus pesan pertama dari antrean. Panggilan berulang ke Receive, oleh karena itu, mengembalikan pesan yang berbeda.

Pesan Mengantre pesan pesan dalam antrean sesuai dengan prioritas dan waktu kedatangan. Pesan yang lebih baru ditempatkan sebelum pesan yang lebih lama hanya jika memiliki prioritas yang lebih tinggi.

Gunakan Peek ketika dapat diterima agar utas saat ini diblokir saat menunggu pesan tiba dalam antrean. Karena kelebihan beban ini tidak menentukan waktu habis, aplikasi mungkin menunggu tanpa batas waktu. Jika Anda memerlukan pemrosesan aplikasi untuk melanjutkan tanpa menunggu, gunakan metode asinkron BeginPeek . Atau, Anda dapat menentukan waktu habis agar pesan tiba dalam antrean dengan menggunakan kelebihan beban Peek yang menentukan waktu habis.

Tabel berikut menunjukkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja Tersedia
Komputer lokal Ya
Komputer lokal dan nama format langsung Ya
Komputer jarak jauh Tidak
Komputer jarak jauh dan nama format langsung Ya

Lihat juga

Berlaku untuk

Peek(TimeSpan)

Mengembalikan tanpa menghapus (mengintip) pesan pertama dalam antrean yang direferensikan oleh ini MessageQueue. Metode Peek() ini sinkron, sehingga memblokir utas saat ini hingga pesan tersedia atau waktu habis yang ditentukan terjadi.

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

TimeSpan yang menunjukkan waktu maksimum untuk menunggu antrean berisi pesan.

Mengembalikan

Message

Message yang mewakili pesan pertama dalam antrean.

Pengecualian

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid, mungkin timeout kurang dari Zero atau lebih besar dari InfiniteTimeout.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut menggunakan Peek metode dengan waktu habis nol untuk memeriksa apakah antrean kosong.

#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

Keterangan

Gunakan kelebihan beban ini untuk mengintip antrean, atau untuk menunggu periode waktu tertentu hingga pesan ada dalam antrean. Metode ini segera kembali jika pesan sudah ada dalam antrean.

Metode Peek membaca, tetapi tidak menghapus, pesan pertama dari antrean. Oleh karena itu, panggilan berulang untuk Peek mengembalikan pesan yang sama, kecuali pesan prioritas yang lebih tinggi tiba dalam antrean. Metode ini Receive , di sisi lain, membaca dan menghapus pesan pertama dari antrean. Panggilan berulang ke Receive, oleh karena itu, mengembalikan pesan yang berbeda.

Pesan Mengantre pesan pesan dalam antrean sesuai dengan prioritas dan waktu kedatangan. Pesan yang lebih baru ditempatkan sebelum pesan yang lebih lama hanya jika memiliki prioritas yang lebih tinggi.

Gunakan Peek ketika dapat diterima agar utas saat ini diblokir saat menunggu pesan tiba dalam antrean. Utas akan diblokir hingga periode waktu yang ditentukan, atau tanpa batas waktu jika Anda menunjukkan InfiniteTimeout. Jika Anda memerlukan pemrosesan aplikasi untuk melanjutkan tanpa menunggu, gunakan metode asinkron BeginPeek .

Tabel berikut menunjukkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja Tersedia
Komputer lokal Ya
Komputer lokal dan nama format langsung Ya
Komputer jarak jauh Tidak
Komputer jarak jauh dan nama format langsung Ya

Lihat juga

Berlaku untuk

Peek(TimeSpan, Cursor, PeekAction)

Mengembalikan tanpa menghapus (mengintip) pesan saat ini atau berikutnya dalam antrean, menggunakan kursor yang ditentukan. Metode Peek() ini sinkron, sehingga memblokir utas saat ini sampai pesan tersedia atau waktu habis yang ditentukan terjadi.

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

TimeSpan yang menunjukkan waktu maksimum untuk menunggu antrean berisi pesan.

cursor
Cursor

Cursor yang mempertahankan posisi tertentu dalam antrean pesan.

action
PeekAction

Salah PeekAction satu nilai. Menunjukkan apakah akan mengintip pesan saat ini dalam antrean, atau pesan berikutnya.

Mengembalikan

Message

Message yang mewakili pesan dalam antrean.

Pengecualian

ArgumentOutOfRangeException

Nilai selain PeekAction.Current atau PeekAction.Next ditentukan untuk action parameter .

ArgumentNullException

Parameternya cursor adalah null.

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid. timeout Mungkin kurang dari Zero atau lebih besar dari InfiniteTimeout.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Keterangan

Gunakan kelebihan beban ini untuk mengintip antrean, atau untuk menunggu periode waktu tertentu hingga pesan ada dalam antrean. Metode ini segera kembali jika pesan sudah ada dalam antrean.

Metode Peek membaca, tetapi tidak menghapus, pesan dari antrean. Metode ini Receive , di sisi lain, membaca dan menghapus pesan dari antrean.

Gunakan Peek ketika dapat diterima agar utas saat ini diblokir saat menunggu pesan tiba dalam antrean. Utas diblokir hingga periode waktu yang ditentukan, atau tanpa batas waktu jika Anda menunjukkan InfiniteTimeout. Jika Anda memerlukan pemrosesan aplikasi untuk melanjutkan tanpa menunggu, gunakan metode asinkron BeginPeek .

Tabel berikut menunjukkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja Tersedia
Komputer lokal Ya
Komputer lokal dan nama format langsung Ya
Komputer jarak jauh Tidak
Komputer jarak jauh dan nama format langsung Ya

Lihat juga

Berlaku untuk

Keamanan Thread

Metode ini tidak aman untuk utas.