MessageQueue.Receive 方法

参考

定义

命名空间:: System.Messaging

程序集:: System.Messaging.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

接收队列中的第一条消息，但不将它从队列中移除。

重载

Receive()	接收 MessageQueue 引用的队列中可用的第一条消息。此调用是同步的，在有可用消息前，它将一直阻止当前线程的执行。
Receive(MessageQueueTransaction)	接收 MessageQueue 引用的事务性队列中可用的第一条消息。此调用是同步的，在有可用消息前，它将一直阻止当前线程的执行。
Receive(MessageQueueTransactionType)	接收 MessageQueue 引用的队列中可用的第一条消息。此调用是同步的，在有可用消息前，它将一直阻止当前线程的执行。
Receive(TimeSpan)	接收由 MessageQueue 引用的队列中的第一条可用消息，并且一直等到队列中有可用消息或超时过期。
Receive(TimeSpan, Cursor)	使用指定的游标接收队列中的当前消息。如果没有可用的消息，此方法将等待，直到有可用的消息或超时到期为止。
Receive(TimeSpan, MessageQueueTransaction)	接收由 MessageQueue 引用的事务性队列中的第一条可用消息，并且一直等到队列中有可用消息或超时过期。
Receive(TimeSpan, MessageQueueTransactionType)	接收 MessageQueue 引用的队列中可用的第一条消息。此调用是同步的，并且一直等到队列中有可用的消息或超时到期。
Receive(TimeSpan, Cursor, MessageQueueTransaction)	使用指定的游标接收队列中的当前消息。如果没有可用的消息，此方法将等待，直到有可用的消息或超时到期为止。
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	使用指定的游标接收队列中的当前消息。如果没有可用的消息，此方法将等待，直到有可用的消息或超时到期为止。

Receive()

接收 MessageQueue 引用的队列中可用的第一条消息。此调用是同步的，在有可用消息前，它将一直阻止当前线程的执行。

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

public System.Messaging.Message Receive ();

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

Public Function Receive () As Message

Message

Message，它引用队列中可用的第一条消息。

例外

MessageQueueException

访问“消息队列”方法时出错。

示例

下面的代码示例从队列接收消息，并将有关该消息的信息输出到屏幕。

#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

注解

使用此重载从队列接收消息，或等到队列中有消息。

方法 Receive 允许同步读取消息，从而将其从队列中删除。对的 Receive 后续调用将返回队列中后面的消息，或更高优先级的新消息。

若要读取队列中的第一条消息而不将其从队列中删除，请使用 Peek 方法。方法 Peek 始终返回队列中的第一条消息，因此对方法的后续调用将返回相同的消息，除非优先级较高的消息到达队列。

当当前线程等待消息到达队列时可以接受阻止时，请使用对的调用 Receive 。由于方法的 Receive 此重载指定无限超时，因此应用程序可能会无限期等待。如果应用程序处理应在不等待消息的情况下继续，请考虑使用异步方法 BeginReceive。

下表显示了此方法是否在各种工作组模式下可用。

工作组模式	可用
本地计算机	是
本地计算机和直接格式名称	是
远程计算机	否
远程计算机和直接格式名称	是

另请参阅

适用于

Receive(MessageQueueTransaction)

接收 MessageQueue 引用的事务性队列中可用的第一条消息。此调用是同步的，在有可用消息前，它将一直阻止当前线程的执行。

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

参数

transaction: MessageQueueTransaction

MessageQueueTransaction 对象。

Message

Message，它引用队列中可用的第一条消息。

例外

MessageQueueException

访问“消息队列”方法时出错。

- 或 -

该队列为非事务性队列。

示例

下面的代码示例连接到本地计算机上的事务队列，并向该队列发送消息。然后，它接收包含订单的消息。如果遇到非事务性队列，它将引发异常并回滚事务。

#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

注解

使用此重载通过参数定义的 transaction 内部事务上下文从事务队列接收消息，或等待队列中有消息。

方法 Receive 允许同步读取消息，从而将其从队列中删除。对的 Receive 后续调用将返回队列中后面的消息。

由于此方法是在事务队列上调用的，因此如果事务中止，收到的消息将返回到队列。在提交事务之前，不会从队列中永久删除消息。

若要读取队列中的第一条消息而不将其从队列中删除，请使用 Peek 方法。方法 Peek 始终返回队列中的第一条消息，因此对方法的后续调用将返回相同的消息，除非优先级较高的消息到达队列。没有与调用 Peek返回的消息关联的事务上下文。由于 Peek 不删除队列中的任何消息，因此调用将没有任何内容可回滚 Abort。

下表显示了此方法是否在各种工作组模式下可用。

工作组模式	可用
本地计算机	是
本地计算机和直接格式名称	是
远程计算机	否
远程计算机和直接格式名称	是

另请参阅

适用于

Receive(MessageQueueTransactionType)

接收 MessageQueue 引用的队列中可用的第一条消息。此调用是同步的，在有可用消息前，它将一直阻止当前线程的执行。

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

参数

transactionType: MessageQueueTransactionType

MessageQueueTransactionType 值之一，它描述与消息关联的事务上下文的类型。

Message

Message，它引用队列中可用的第一条消息。

例外

MessageQueueException

访问“消息队列”方法时出错。

InvalidEnumArgumentException

transactionType 参数不是 MessageQueueTransactionType 成员之一。

示例

以下代码示例演示了 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);

注解

使用此重载通过参数定义的 transactionType 事务上下文从队列接收消息，或等待队列中有消息。

如果已将外部事务上下文附加到要用于接收消息的线程，请为 transactionType 参数指定 Automatic 。指定 Single 是否要以单个内部事务的形式接收消息。可以指定 None 是否要从事务上下文之外的事务队列接收消息。

方法 Receive 允许同步读取消息，从而将其从队列中删除。对的后续调用 Receive 将返回队列中紧随其后的消息。

如果调用此方法以接收来自事务队列的消息，则事务中止时收到的消息将返回到队列。在提交事务之前，不会从队列中永久删除该消息。

若要读取队列中的第一条消息而不将其从队列中删除，请使用 Peek 方法。方法 Peek 始终返回队列中的第一条消息，因此对方法的后续调用将返回相同的消息，除非队列中到达了更高优先级的消息。没有与调用 Peek返回的消息关联的事务上下文。由于 Peek 不会删除队列中的任何消息，因此调用不会回滚 Abort任何消息。

如果当前线程在等待消息到达队列时可以接受阻止，请使用对的调用 Receive 。由于方法的 Receive 此重载指定了无限超时，因此应用程序可能会无限期等待。如果应用程序处理应继续而不等待消息，请考虑使用异步方法 BeginReceive。

下表显示了此方法在各种工作组模式下是否可用。

工作组模式	可用
本地计算机	是
本地计算机和直接格式名称	是
远程计算机	否
远程计算机和直接格式名称	是

另请参阅

适用于

Receive(TimeSpan)

接收由 MessageQueue 引用的队列中的第一条可用消息，并且一直等到队列中有可用消息或超时过期。

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

参数

timeout: TimeSpan

一个 TimeSpan 指示有新消息可用于检查之前等待的时间。

Message

Message，它引用队列中可用的第一条消息。

例外

ArgumentException

为 timeout 参数指定的值无效，可能是 timeout 小于 Zero 或大于 InfiniteTimeout。

MessageQueueException

在超时过期之前消息没有到达队列。

- 或 -

访问“消息队列”方法时出错。

示例

下面的代码示例从队列接收消息，并将有关该消息的信息输出到屏幕。该示例在等待消息到达队列时暂停执行最多五秒钟。

#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

注解

使用此重载接收消息并在队列中没有消息时在指定的时间段内返回。

方法 Receive 允许同步读取消息，将其从队列中删除。对的后续调用 Receive 将返回队列中后面的消息，或新的、优先级更高的消息。

若要读取队列中的第一条消息而不将其从队列中删除，请使用 Peek 方法。方法 Peek 始终返回队列中的第一条消息，因此对方法的后续调用将返回相同的消息，除非队列中到达了更高优先级的消息。

如果当前线程在等待消息到达队列时可以接受阻止，请使用对的调用 Receive 。线程将在给定的时间段内被阻止;如果为 timeout 参数指定了值InfiniteTimeout，则将无限期阻止该线程。如果应用程序处理应继续而不等待消息，请考虑使用异步方法 BeginReceive。

下表显示了此方法在各种工作组模式下是否可用。

工作组模式	可用
本地计算机	是
本地计算机和直接格式名称	是
远程计算机	否
远程计算机和直接格式名称	是

另请参阅

适用于

Receive(TimeSpan, Cursor)

使用指定的游标接收队列中的当前消息。如果没有可用的消息，此方法将等待，直到有可用的消息或超时到期为止。

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

参数

timeout: TimeSpan

一个 TimeSpan 指示有新消息可用于检查之前等待的时间。

cursor: Cursor

维持消息队列中特定位置的 Cursor。

Message

Message，它引用队列中可用的第一条消息。

例外

ArgumentException

为 timeout 参数指定的值无效，可能是 timeout 小于 Zero 或大于 InfiniteTimeout。

MessageQueueException

在超时过期之前消息没有到达队列。

- 或 -

访问“消息队列”方法时出错。

使用此重载接收消息并在队列中没有消息时在指定的时间段内返回。

适用于

Receive(TimeSpan, MessageQueueTransaction)

接收由 MessageQueue 引用的事务性队列中的第一条可用消息，并且一直等到队列中有可用消息或超时过期。

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

参数

timeout: TimeSpan

一个 TimeSpan 指示有新消息可用于检查之前等待的时间。

transaction: MessageQueueTransaction

MessageQueueTransaction 对象。

Message

Message，它引用队列中可用的第一条消息。

例外

ArgumentException

为 timeout 参数指定的值无效，可能是 timeout 小于 Zero 或大于 InfiniteTimeout。

MessageQueueException

在超时过期之前消息没有到达队列。

- 或 -

该队列为非事务性队列。

- 或 -

访问“消息队列”方法时出错。

示例

下面的代码示例演示了此方法的使用。

#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

注解

使用此重载通过参数定义的 transaction 内部事务上下文从事务队列接收消息，如果队列中没有消息，则返回在指定时间段内。

方法 Receive 允许同步读取消息，从而将其从队列中删除。对的后续调用 Receive 将返回队列中紧随其后的消息。

由于此方法是在事务队列上调用的，因此，如果事务中止，收到的消息将返回到队列。在提交事务之前，不会从队列中永久删除该消息。

下表显示了此方法在各种工作组模式下是否可用。

工作组模式	可用
本地计算机	是
本地计算机和直接格式名称	是
远程计算机	否
远程计算机和直接格式名称	是

另请参阅

适用于

Receive(TimeSpan, MessageQueueTransactionType)

接收 MessageQueue 引用的队列中可用的第一条消息。此调用是同步的，并且一直等到队列中有可用的消息或超时到期。

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

参数

timeout: TimeSpan

一个 TimeSpan 指示有新消息可用于检查之前等待的时间。

transactionType: MessageQueueTransactionType

MessageQueueTransactionType 值之一，它描述与消息关联的事务上下文的类型。

Message

Message，它引用队列中可用的第一条消息。

例外

ArgumentException

为 timeout 参数指定的值无效，可能是 timeout 小于 Zero 或大于 InfiniteTimeout。

InvalidEnumArgumentException

transactionType 参数不是 MessageQueueTransactionType 成员之一。

MessageQueueException

在超时过期之前消息没有到达队列。

- 或 -

访问“消息队列”方法时出错。

示例

下面的代码示例演示了此方法的使用。


// 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);

注解

使用此重载通过参数定义的 transactionType 事务上下文从队列接收消息，如果队列中没有消息，则会在指定时间段内返回。

如果已将外部事务上下文附加到要用于接收消息的线程，则为 transactionType 参数指定 Automatic 。指定 Single 是否要以单个内部事务的形式接收消息。可以指定 None 是否要从事务上下文之外的事务队列接收消息。

方法 Receive 允许同步读取消息，从而将其从队列中删除。对的后续调用 Receive 将返回队列中紧随其后的消息。

如果调用此方法以接收来自事务队列的消息，则事务中止时收到的消息将返回到队列。在提交事务之前，不会从队列中永久删除该消息。

下表显示了此方法在各种工作组模式下是否可用。

工作组模式	可用
本地计算机	是
本地计算机和直接格式名称	是
远程计算机	否
远程计算机和直接格式名称	是

另请参阅

适用于

Receive(TimeSpan, Cursor, MessageQueueTransaction)

使用指定的游标接收队列中的当前消息。如果没有可用的消息，此方法将等待，直到有可用的消息或超时到期为止。

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

参数

timeout: TimeSpan

一个 TimeSpan 指示有新消息可用于检查之前等待的时间。

cursor: Cursor

维持消息队列中特定位置的 Cursor。

transaction: MessageQueueTransaction

MessageQueueTransaction 对象。

Message

一个 Message，它引用队列中的一条消息。

例外

ArgumentNullException

cursor 参数为 null。

- 或 -

transaction 参数为 null。

ArgumentException

为 timeout 参数指定的值无效。 timeout 可能小于 Zero 或大于 InfiniteTimeout。

MessageQueueException

在超时过期之前消息没有到达队列。

- 或 -

该队列为非事务性队列。

- 或 -

访问“消息队列”方法时出错。

注解

使用此重载通过参数定义的 transaction 内部事务上下文从事务队列接收消息，如果队列中没有消息，则返回在指定时间段内。

方法 Receive 允许同步读取消息，从而将其从队列中删除。对返回队列中随后的消息的后续调用 Receive 。

由于此方法是在事务队列上调用的，因此，如果事务中止，收到的消息将返回到队列。在提交事务之前，不会从队列中永久删除该消息。

若要读取队列中的消息而不将其从队列中删除，请使用 Peek 方法。没有与调用 Peek返回的消息关联的事务上下文。由于 Peek 不会删除队列中的任何消息，因此调用不会回滚 Abort任何消息。

如果当前线程在等待消息到达队列时可以接受阻止，请使用对的调用 Receive 。线程在给定的时间段内被阻止;如果为 timeout 参数指定了值InfiniteTimeout，则无限期阻止该线程。如果应用程序处理应继续而不等待消息，请考虑使用异步方法 BeginReceive。

下表显示了此方法在各种工作组模式下是否可用。

工作组模式	可用
本地计算机	是
本地计算机和直接格式名称	是
远程计算机	否
远程计算机和直接格式名称	是

另请参阅

适用于

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

使用指定的游标接收队列中的当前消息。如果没有可用的消息，此方法将等待，直到有可用的消息或超时到期为止。

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

参数

timeout: TimeSpan

一个 TimeSpan 指示有新消息可用于检查之前等待的时间。

cursor: Cursor

维持消息队列中特定位置的 Cursor。

transactionType: MessageQueueTransactionType

MessageQueueTransactionType 值之一，它描述与消息关联的事务上下文类型。

Message

一个 Message，它引用队列中的一条消息。

例外

ArgumentNullException

cursor 参数为 null。

ArgumentException

为 timeout 参数指定的值无效。 timeout 可能小于 Zero 或大于 InfiniteTimeout。

InvalidEnumArgumentException

transactionType 参数不是 MessageQueueTransactionType 成员之一。

MessageQueueException

在超时过期之前消息没有到达队列。

- 或 -

访问“消息队列”方法时出错。

注解

使用此重载通过参数定义的 transactionType 事务上下文从队列接收消息，如果队列中没有消息，则会在指定时间段内返回。

方法 Receive 允许同步读取消息，从而将其从队列中删除。对返回队列中随后的消息的后续调用 Receive 。

如果调用此方法以接收来自事务队列的消息，则事务中止时，收到的消息将返回到队列。在提交事务之前，不会从队列中永久删除该消息。

下表显示了此方法在各种工作组模式下是否可用。

工作组模式	可用
本地计算机	是
本地计算机和直接格式名称	是
远程计算机	否
远程计算机和直接格式名称	是

另请参阅

适用于

线程安全性

方法不是线程安全的。

通过

MessageQueue.Receive 方法

定义

重载

Receive()

返回

例外

示例

注解

另请参阅

适用于

Receive(MessageQueueTransaction)

参数

返回

例外

示例

注解

另请参阅

适用于

Receive(MessageQueueTransactionType)

参数

返回

例外

示例

注解

另请参阅

适用于

Receive(TimeSpan)

参数

返回

例外

示例

注解

另请参阅

适用于

Receive(TimeSpan, Cursor)

参数

返回

例外

适用于

Receive(TimeSpan, MessageQueueTransaction)

参数

返回

例外

示例

注解

另请参阅

适用于

Receive(TimeSpan, MessageQueueTransactionType)

参数

返回

例外

示例

注解

另请参阅

适用于

Receive(TimeSpan, Cursor, MessageQueueTransaction)

参数

返回

例外

注解

另请参阅

适用于

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

参数

返回

例外

注解

另请参阅

适用于

线程安全性

其他资源