MessageQueue.Receive Metode

Referensi

Definisi

Ruang nama:: System.Messaging

Rakitan:: System.Messaging.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Menerima pesan pertama dalam antrean, menghapusnya dari antrean.

Overload

Receive()	Menerima pesan pertama yang tersedia dalam antrean yang direferensikan MessageQueueoleh . Panggilan ini sinkron, dan memblokir utas eksekusi saat ini hingga pesan tersedia.
Receive(MessageQueueTransaction)	Menerima pesan pertama yang tersedia dalam antrean transaksi yang direferensikan oleh MessageQueue. Panggilan ini sinkron, dan memblokir utas eksekusi saat ini hingga pesan tersedia.
Receive(MessageQueueTransactionType)	Menerima pesan pertama yang tersedia dalam antrean yang direferensikan MessageQueueoleh . Panggilan ini sinkron, dan memblokir utas eksekusi saat ini hingga pesan tersedia.
Receive(TimeSpan)	Menerima pesan pertama yang tersedia dalam antrean yang direferensikan oleh MessageQueue dan menunggu hingga pesan tersedia dalam antrean, atau waktu habis kedaluwarsa.
Receive(TimeSpan, Cursor)	Menerima pesan saat ini dalam antrean, menggunakan kursor tertentu. Jika tidak ada pesan yang tersedia, metode ini menunggu hingga pesan tersedia, atau waktu habis kedaluwarsa.
Receive(TimeSpan, MessageQueueTransaction)	Menerima pesan pertama yang tersedia dalam antrean transaksi yang direferensikan oleh MessageQueue dan menunggu hingga pesan tersedia dalam antrean, atau waktu habis kedaluwarsa.
Receive(TimeSpan, MessageQueueTransactionType)	Menerima pesan pertama yang tersedia dalam antrean yang direferensikan MessageQueueoleh . Panggilan ini sinkron, dan menunggu hingga pesan tersedia dalam antrean, atau waktu habis kedaluwarsa.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Menerima pesan saat ini dalam antrean, menggunakan kursor tertentu. Jika tidak ada pesan yang tersedia, metode ini menunggu hingga pesan tersedia, atau waktu habis kedaluwarsa.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Menerima pesan saat ini dalam antrean, menggunakan kursor tertentu. Jika tidak ada pesan yang tersedia, metode ini menunggu hingga pesan tersedia, atau waktu habis kedaluwarsa.

Receive()

Menerima pesan pertama yang tersedia dalam antrean yang direferensikan MessageQueueoleh . Panggilan ini sinkron, dan memblokir utas eksekusi saat ini hingga pesan tersedia.

public:
 System::Messaging::Message ^ Receive();

public System.Messaging.Message Receive ();

member this.Receive : unit -> System.Messaging.Message

Public Function Receive () As Message

Mengembalikan

Message

Message yang mereferensikan pesan pertama yang tersedia dalam antrean.

Pengecualian

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut menerima pesan dari antrean dan menghasilkan informasi tentang pesan tersebut ke layar.

#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:

   //*************************************************
   // 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;
   }

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         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 sends and receives a message from
// a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   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 sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            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;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                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 receives 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 sends and receives a message from
        ' a qeue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            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


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate the body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                Dim myMessage As Message = myQueue.Receive()
                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 menerima pesan dari antrean, atau tunggu hingga ada pesan dalam antrean.

Metode ini Receive memungkinkan pembacaan pesan yang sinkron, sehingga menghapusnya dari antrean. Panggilan berikutnya ke Receive akan mengembalikan pesan yang mengikuti dalam antrean, atau pesan prioritas baru yang lebih tinggi.

Gunakan panggilan ke Receive ketika dapat diterima agar utas saat ini diblokir saat menunggu pesan tiba dalam antrean. Karena kelebihan beban Receive metode ini menentukan waktu habis yang tak terbatas, aplikasi mungkin menunggu tanpa batas waktu. Jika pemrosesan aplikasi harus dilanjutkan tanpa menunggu pesan, pertimbangkan untuk menggunakan metode asinkron, BeginReceive.

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

Receive(MessageQueueTransaction)

Menerima pesan pertama yang tersedia dalam antrean transaksi yang direferensikan oleh MessageQueue. Panggilan ini sinkron, dan memblokir utas eksekusi saat ini hingga pesan tersedia.

public:
 System::Messaging::Message ^ Receive(System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive (System.Messaging.MessageQueueTransaction transaction);

member this.Receive : System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (transaction As MessageQueueTransaction) As Message

Parameter

transaction: MessageQueueTransaction

Objek MessageQueueTransaction.

Mengembalikan

Message

Message yang mereferensikan pesan pertama yang tersedia dalam antrean.

Pengecualian

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

-atau-

Antrean tidak transaksi.

Contoh

Contoh kode berikut tersambung ke antrean transaksional di komputer lokal dan mengirim pesan ke antrean. Kemudian menerima pesan yang berisi pesanan. Jika mengalami antrean non-transaksi, itu akan melemparkan dan pengecualian dan memutar kembali transaksi.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends a message to a queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }


   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessageTransactional()
   {
      // Connect to a transactional queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         Message^ myMessage = myQueue->Receive( myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }

         // Else catch other sources of a MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
// 
// This example sends and receives a message from
// a transactional queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessageTransactional();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   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 sends and receives a message from
        // a transactional queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessageTransactional();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();

            return;
        }

        //**************************************************
        // Sends a message to a queue.
        //**************************************************
        
        public void SendMessageTransactional()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessageTransactional()
        {
            // Connect to a transactional queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                Message myMessage =	myQueue.Receive(myTransaction);
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }
                
                // Else catch other sources of a MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        ' 
        ' This example sends and receives a message from
        ' a transactional queue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue

            ' Send a message to a queue.
            myNewQueue.SendMessageTransactional()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional()

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessageTransactional()

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

            End If

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessageTransactional()

            ' Connect to a transactional queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                Dim myMessage As Message = _
                    myQueue.Receive(myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                End If

                ' Else catch other sources of a MessageQueueException.


                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as 
                ' InvalidOperationException, thrown when the formatter
                ' cannot deserialize the message.

            End Try

            Return

        End Sub

End Class

Keterangan

Gunakan kelebihan beban ini untuk menerima pesan dari antrean transaksi menggunakan konteks transaksi internal yang ditentukan oleh transaction parameter , atau tunggu hingga ada pesan dalam antrean.

Metode ini Receive memungkinkan pembacaan pesan yang sinkron, sehingga menghapusnya dari antrean. Panggilan berikutnya ke Receive akan mengembalikan pesan yang mengikuti dalam antrean.

Karena metode ini dipanggil pada antrean transaksional, pesan yang diterima akan dikembalikan ke antrean jika transaksi dibatalkan. Pesan tidak dihapus secara permanen dari antrean hingga transaksi dilakukan.

Untuk membaca pesan pertama dalam antrean tanpa menghapusnya dari antrean, gunakan Peek metode . Metode Peek selalu mengembalikan pesan pertama dalam antrean, sehingga panggilan berikutnya ke metode mengembalikan pesan yang sama kecuali pesan prioritas yang lebih tinggi tiba dalam antrean. Tidak ada konteks transaksi yang terkait dengan pesan yang dikembalikan oleh panggilan ke Peek. Karena Peek tidak menghapus pesan apa pun dalam antrean, tidak akan ada yang perlu digulung balik oleh panggilan ke Abort.

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

Receive(MessageQueueTransactionType)

Menerima pesan pertama yang tersedia dalam antrean yang direferensikan MessageQueueoleh . Panggilan ini sinkron, dan memblokir utas eksekusi saat ini hingga pesan tersedia.

public:
 System::Messaging::Message ^ Receive(System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive (System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (transactionType As MessageQueueTransactionType) As Message

Parameter

transactionType: MessageQueueTransactionType

Salah MessageQueueTransactionType satu nilai, yang menjelaskan jenis konteks transaksi untuk dikaitkan dengan pesan.

Mengembalikan

Message

Message Yang mereferensikan pesan pertama yang tersedia dalam antrean.

Pengecualian

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

InvalidEnumArgumentException

Parameter transactionType bukan salah MessageQueueTransactionType satu anggota.

Contoh

Contoh kode berikut menunjukkan penggunaan Receive(MessageQueueTransactionType).


// Connect to a transactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

// Simulate doing other work so the message has time to arrive.
System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));

// Set the formatter to indicate the message body contains a String.
queue->Formatter = gcnew XmlMessageFormatter(
    gcnew array<Type^>{String::typeid});

// Receive the message from the queue.  Because the Id of the message
// , it might not be the message just sent.
msg = queue->Receive(MessageQueueTransactionType::Single);

queue->Close();


// Connect to a transactional queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

// Simulate doing other work so the message has time to arrive.
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

// Set the formatter to indicate the message body contains a String.
queue.Formatter = new XmlMessageFormatter(new Type[]
    {typeof(String)});

// Receive the message from the queue.  Because the Id of the message
// , it might not be the message just sent.
msg = queue.Receive(MessageQueueTransactionType.Single);

Keterangan

Gunakan kelebihan beban ini untuk menerima pesan dari antrean menggunakan konteks transaksi yang ditentukan oleh transactionType parameter, atau tunggu hingga ada pesan dalam antrean.

Tentukan Automatic untuk transactionType parameter jika sudah ada konteks transaksi eksternal yang dilampirkan ke utas yang ingin Anda gunakan untuk menerima pesan. Tentukan Single apakah Anda ingin menerima pesan sebagai satu transaksi internal. Anda dapat menentukan None apakah Anda ingin menerima pesan dari antrean transaksi di luar konteks transaksi.

Metode ini Receive memungkinkan pembacaan pesan yang sinkron, sehingga menghapusnya dari antrean. Panggilan berikutnya ke Receive akan mengembalikan pesan yang mengikuti dalam antrean.

Jika metode ini dipanggil untuk menerima pesan dari antrean transaksi, pesan yang diterima akan dikembalikan ke antrean jika transaksi dibatalkan. Pesan tidak dihapus secara permanen dari antrean hingga transaksi dilakukan.

Untuk membaca pesan pertama dalam antrean tanpa menghapusnya dari antrean, gunakan Peek metode . Metode Peek ini selalu mengembalikan pesan pertama dalam antrean, sehingga panggilan berikutnya ke metode mengembalikan pesan yang sama kecuali pesan prioritas yang lebih tinggi tiba dalam antrean. Tidak ada konteks transaksi yang terkait dengan pesan yang dikembalikan oleh panggilan ke Peek. Karena Peek tidak menghapus pesan apa pun dalam antrean, tidak akan ada yang digulung balik oleh panggilan ke Abort.

Gunakan panggilan ke Receive ketika dapat diterima agar utas saat ini diblokir saat menunggu pesan tiba dalam antrean. Karena kelebihan metode Receive ini menentukan waktu habis yang tak terbatas, aplikasi mungkin menunggu tanpa batas waktu. Jika pemrosesan aplikasi harus dilanjutkan tanpa menunggu pesan, pertimbangkan untuk menggunakan metode asinkron, BeginReceive.

Tabel berikut ini memperlihatkan 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

Receive(TimeSpan)

Menerima pesan pertama yang tersedia dalam antrean yang direferensikan oleh MessageQueue dan menunggu hingga pesan tersedia dalam antrean, atau waktu habis kedaluwarsa.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout);

public System.Messaging.Message Receive (TimeSpan timeout);

member this.Receive : TimeSpan -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan) As Message

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan waktu untuk menunggu hingga pesan baru tersedia untuk diperiksa.

Mengembalikan

Message

Message Yang mereferensikan pesan pertama yang tersedia dalam antrean.

Pengecualian

ArgumentException

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

MessageQueueException

Pesan tidak tiba dalam antrean sebelum waktu habis kedaluwarsa.

-atau-

Terjadi kesalahan saat mengakses metode Antrean Pesan

Contoh

Contoh kode berikut menerima pesan dari antrean dan menghasilkan informasi tentang pesan tersebut ke layar. Contoh menjeda eksekusi hingga lima detik sambil menunggu pesan tiba dalam antrean.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// 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:

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         // Wait 5 seconds for a message to arrive.
         Message^ myMessage = myQueue->Receive( TimeSpan(0,0,5) );
         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^ e ) 
      {
         // Handle no message arriving in the queue.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( "No message arrived in queue." );
         }

         // Handle other sources of a MessageQueueException.
      }
      // 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 receives a message from a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    // This class represents an object the following example
    // 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 receives a message from a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************

        public void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                // Wait 5 seconds for a message to arrive.
                Message myMessage =	myQueue.Receive(new
                    TimeSpan(0,0,5));
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }

            catch (MessageQueueException e)
            {
                // Handle no message arriving in the queue.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine("No message arrived in queue.");
                }			

                // Handle other sources of a MessageQueueException.
            }
            
            // 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 
' receives 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 receives a message from a queue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                ' Wait 5 seconds for a message to arrive.
                Dim myMessage As Message = myQueue.Receive(New _
                    TimeSpan(0, 0, 5))
                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 e As MessageQueueException
                ' Handle no message arriving in the queue.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    Console.WriteLine("No message arrived in queue.")

                End If

                ' Handle other sources of a MessageQueueException.

            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 menerima pesan dan kembali dalam jangka waktu tertentu jika tidak ada pesan dalam antrean.

Metode ini Receive memungkinkan pembacaan pesan yang sinkron, menghapusnya dari antrean. Panggilan berikutnya ke Receive akan mengembalikan pesan yang mengikuti dalam antrean, atau pesan prioritas baru yang lebih tinggi.

Gunakan panggilan ke Receive ketika dapat diterima agar utas saat ini diblokir saat menunggu pesan tiba dalam antrean. Utas akan diblokir untuk jangka waktu tertentu, atau tanpa batas waktu jika Anda menentukan nilai InfiniteTimeout untuk timeout parameter . Jika pemrosesan aplikasi harus dilanjutkan tanpa menunggu pesan, pertimbangkan untuk menggunakan metode asinkron, BeginReceive.

Tabel berikut ini memperlihatkan 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

Receive(TimeSpan, Cursor)

Menerima pesan saat ini dalam antrean, menggunakan kursor tertentu. Jika tidak ada pesan yang tersedia, metode ini menunggu hingga pesan tersedia, atau waktu habis berakhir.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor);

member this.Receive : TimeSpan * System.Messaging.Cursor -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor) As Message

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan waktu untuk menunggu hingga pesan baru tersedia untuk diperiksa.

cursor: Cursor

Cursor yang mempertahankan posisi tertentu dalam antrean pesan.

Mengembalikan

Message

Message Yang mereferensikan pesan pertama yang tersedia dalam antrean.

Pengecualian

ArgumentException

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

MessageQueueException

Pesan tidak tiba dalam antrean sebelum waktu habis kedaluwarsa.

-atau-

Terjadi kesalahan saat mengakses metode Antrean Pesan

Gunakan kelebihan beban ini untuk menerima pesan dan kembali dalam jangka waktu tertentu jika tidak ada pesan dalam antrean.

Berlaku untuk

Receive(TimeSpan, MessageQueueTransaction)

Menerima pesan pertama yang tersedia dalam antrean transaksi yang direferensikan oleh MessageQueue dan menunggu hingga pesan tersedia dalam antrean, atau waktu habis kedaluwarsa.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.MessageQueueTransaction transaction);

member this.Receive : TimeSpan * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, transaction As MessageQueueTransaction) As Message

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan waktu untuk menunggu hingga pesan baru tersedia untuk diperiksa.

transaction: MessageQueueTransaction

Objek MessageQueueTransaction.

Mengembalikan

Message

Message Yang mereferensikan pesan pertama yang tersedia dalam antrean.

Pengecualian

ArgumentException

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

MessageQueueException

Pesan tidak tiba dalam antrean sebelum waktu habis kedaluwarsa.

-atau-

Antrean bersifat non-transaksi.

-atau-

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut menunjukkan penggunaan metode ini.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends a message to a transactional queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }

   //*************************************************
   // Receives a message from the transactional queue.
   //*************************************************
   void ReceiveMessageTransactional()
   {
      // Connect to a transactional queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         // Wait five seconds for a message to arrive. 
         Message^ myMessage = myQueue->Receive( TimeSpan(0,0,5), myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }
         // Handle no message arriving in the queue.
         else

         // Handle no message arriving in the queue.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( "No message in queue." );
         }

         // Else catch other sources of MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
// 
// This example sends and receives a message from
// a transactional queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessageTransactional();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   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 sends and receives a message from
        // a transactional queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessageTransactional();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();

            return;
        }

        //**************************************************
        // Sends a message to a transactional queue.
        //**************************************************
        
        public void SendMessageTransactional()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

        //**************************************************
        // Receives a message from the transactional queue.
        //**************************************************
        
        public  void ReceiveMessageTransactional()
        {
            // Connect to a transactional queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                // Wait five seconds for a message to arrive.
                Message myMessage =	myQueue.Receive(new
                    TimeSpan(0,0,5), myTransaction);
                
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }

                    // Handle no message arriving in the queue.
                else if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine("No message in queue.");
                }
                
                // Else catch other sources of MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}

Imports System.Messaging

Namespace MyProj


   
    Public Class MyNewQueue


        '**************************************************
        ' Provides an entry point into the application.
        ' 
        ' This example sends and receives a message from
        ' a transactional queue.
        '**************************************************

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue

            ' Send a message to a queue.
            myNewQueue.SendMessageTransactional()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional()

            Return

        End Sub


        '**************************************************
        ' Sends a message to a transactional queue.
        '**************************************************

        Public Sub SendMessageTransactional()

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

            End If

            Return

        End Sub


        '**************************************************
        ' Receives a message from the transactional queue.
        '**************************************************

        Public Sub ReceiveMessageTransactional()

            ' Connect to a transactional queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                ' Wait five seconds for a message to arrive. 
                Dim myMessage As Message = myQueue.Receive(New _
                    TimeSpan(0, 0, 5), myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                Else
                    ' Handle no message arriving in the queue.
                    If e.MessageQueueErrorCode = _
                        MessageQueueErrorCode.IOTimeout Then

                        Console.WriteLine("No message in queue.")

                    End If
                End If

                ' Else catch other sources of a MessageQueueException.

                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as InvalidOperationException,
                ' thrown when the formatter cannot deserialize the message.

            End Try

            Return

        End Sub

    End Class
End Namespace 'MyProj

Keterangan

Gunakan kelebihan beban ini untuk menerima pesan dari antrean transaksi menggunakan konteks transaksi internal yang ditentukan oleh transaction parameter, dan kembali dalam jangka waktu tertentu jika tidak ada pesan dalam antrean.

Metode ini Receive memungkinkan pembacaan pesan yang sinkron, sehingga menghapusnya dari antrean. Panggilan berikutnya ke Receive akan mengembalikan pesan yang mengikuti dalam antrean.

Tabel berikut ini memperlihatkan 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

Receive(TimeSpan, MessageQueueTransactionType)

Menerima pesan pertama yang tersedia dalam antrean yang direferensikan MessageQueueoleh . Panggilan ini sinkron, dan menunggu hingga pesan tersedia dalam antrean, atau waktu habis berakhir.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : TimeSpan * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, transactionType As MessageQueueTransactionType) As Message

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan waktu untuk menunggu hingga pesan baru tersedia untuk diperiksa.

transactionType: MessageQueueTransactionType

Salah MessageQueueTransactionType satu nilai, yang menjelaskan jenis konteks transaksi untuk dikaitkan dengan pesan.

Mengembalikan

Message

Message Yang mereferensikan pesan pertama yang tersedia dalam antrean.

Pengecualian

ArgumentException

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

InvalidEnumArgumentException

Parameter transactionType bukan salah MessageQueueTransactionType satu anggota.

MessageQueueException

Pesan tidak tiba dalam antrean sebelum waktu habis kedaluwarsa.

-atau-

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut menunjukkan penggunaan metode ini.


// Connect to a transactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

// Set the formatter to indicate the message body contains a String.
queue->Formatter = gcnew XmlMessageFormatter(
    gcnew array<Type^>{String::typeid});

// Receive the message from the queue. Because the Id of the message
// is not specified, it might not be the message just sent.
msg = queue->Receive(TimeSpan::FromSeconds(10.0),
    MessageQueueTransactionType::Single);

queue->Close();


// Connect to a transactional queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

// Set the formatter to indicate the message body contains a String.
queue.Formatter = new XmlMessageFormatter(new Type[]
    {typeof(String)});

// Receive the message from the queue. Because the Id of the message
// is not specified, it might not be the message just sent.
msg = queue.Receive(TimeSpan.FromSeconds(10.0),
    MessageQueueTransactionType.Single);

Keterangan

Gunakan kelebihan beban ini untuk menerima pesan dari antrean menggunakan konteks transaksi yang ditentukan oleh transactionType parameter , dan kembali dalam jangka waktu tertentu jika tidak ada pesan dalam antrean.

Metode ini Receive memungkinkan pembacaan pesan yang sinkron, sehingga menghapusnya dari antrean. Panggilan berikutnya ke Receive akan mengembalikan pesan yang mengikuti dalam antrean.

Tabel berikut ini memperlihatkan 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

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Menerima pesan saat ini dalam antrean, menggunakan kursor tertentu. Jika tidak ada pesan yang tersedia, metode ini menunggu hingga pesan tersedia, atau waktu habis berakhir.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransaction transaction);

member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor, transaction As MessageQueueTransaction) As Message

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan waktu untuk menunggu hingga pesan baru tersedia untuk diperiksa.

cursor: Cursor

Cursor yang mempertahankan posisi tertentu dalam antrean pesan.

transaction: MessageQueueTransaction

Objek MessageQueueTransaction.

Mengembalikan

Message

Message yang mereferensikan pesan dalam antrean.

Pengecualian

ArgumentNullException

Parameternya cursor adalah null.

-atau-

Parameternya transaction adalah null.

ArgumentException

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

MessageQueueException

Pesan tidak tiba dalam antrean sebelum waktu habis kedaluwarsa.

-atau-

Antrean bersifat non-transaksi.

-atau-

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Keterangan

Metode ini Receive memungkinkan pembacaan pesan yang sinkron, sehingga menghapusnya dari antrean. Panggilan berikutnya untuk Receive mengembalikan pesan yang mengikuti dalam antrean.

Karena metode ini dipanggil pada antrean transaksional, pesan yang diterima dikembalikan ke antrean jika transaksi dibatalkan. Pesan tidak dihapus secara permanen dari antrean hingga transaksi dilakukan.

Untuk membaca pesan dalam antrean tanpa menghapusnya dari antrean, gunakan Peek metode . Tidak ada konteks transaksi yang terkait dengan pesan yang dikembalikan oleh panggilan ke Peek. Karena Peek tidak menghapus pesan apa pun dalam antrean, tidak ada yang perlu digulung balik oleh panggilan ke Abort.

Gunakan panggilan ke Receive ketika dapat diterima agar utas saat ini diblokir saat menunggu pesan tiba dalam antrean. Utas diblokir untuk jangka waktu tertentu, atau tanpa batas waktu jika Anda menentukan nilai InfiniteTimeout untuk timeout parameter . Jika pemrosesan aplikasi harus dilanjutkan tanpa menunggu pesan, pertimbangkan untuk menggunakan metode asinkron, BeginReceive.

Tabel berikut ini memperlihatkan 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

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Menerima pesan saat ini dalam antrean, menggunakan kursor tertentu. Jika tidak ada pesan yang tersedia, metode ini menunggu hingga pesan tersedia, atau waktu habis kedaluwarsa.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor, transactionType As MessageQueueTransactionType) As Message

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan waktu untuk menunggu hingga pesan baru tersedia untuk diperiksa.

cursor: Cursor

Cursor yang mempertahankan posisi tertentu dalam antrean pesan.

transactionType: MessageQueueTransactionType

Salah MessageQueueTransactionType satu nilai yang menjelaskan jenis konteks transaksi untuk dikaitkan dengan pesan.

Mengembalikan

Message

Message yang mereferensikan pesan dalam antrean.

Pengecualian

ArgumentNullException

Parameternya cursor adalah null.

ArgumentException

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

InvalidEnumArgumentException

Parameter transactionType bukan salah MessageQueueTransactionType satu anggota.

MessageQueueException

Pesan tidak tiba dalam antrean sebelum waktu habis kedaluwarsa.

-atau-

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Keterangan

Metode ini Receive memungkinkan pembacaan pesan yang sinkron, sehingga menghapusnya dari antrean. Panggilan berikutnya untuk Receive mengembalikan pesan yang mengikuti dalam antrean.

Jika metode ini dipanggil untuk menerima pesan dari antrean transaksi, pesan yang diterima dikembalikan ke antrean jika transaksi dibatalkan. Pesan tidak dihapus secara permanen dari antrean hingga transaksi dilakukan.

Tabel berikut ini memperlihatkan 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.

Bagikan melalui

MessageQueue.Receive Metode

Definisi

Overload

Receive()

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Receive(MessageQueueTransaction)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Receive(MessageQueueTransactionType)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Receive(TimeSpan)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Receive(TimeSpan, Cursor)

Parameter

Mengembalikan

Pengecualian

Berlaku untuk

Receive(TimeSpan, MessageQueueTransaction)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Receive(TimeSpan, MessageQueueTransactionType)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

Keamanan Thread

Sumber Daya Tambahan: