MessageQueue.Send 方法

参考

定义

命名空间:: System.Messaging

程序集:: System.Messaging.dll

重要

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

向队列发送对象。

重载

Send(Object)	将对象发送到此 MessageQueue 引用的非事务性队列。
Send(Object, MessageQueueTransaction)	将对象发送到此 MessageQueue 所引用的事务性队列。
Send(Object, MessageQueueTransactionType)	将对象发送到此 MessageQueue 所引用的队列。
Send(Object, String)	将对象发送到此 MessageQueue 引用的非事务性队列，并指定消息的标签。
Send(Object, String, MessageQueueTransaction)	将对象发送到此 MessageQueue 引用的事务性队列中，并指定该消息的标签。
Send(Object, String, MessageQueueTransactionType)	将对象发送到此 MessageQueue 引用的队列中，并指定该消息的标签。

Send(Object)

将对象发送到此 MessageQueue 引用的非事务性队列。

public:
 void Send(System::Object ^ obj);

public void Send (object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

参数

obj: Object

要发送到队列的对象。

例外

MessageQueueException

尚未设置 Path 属性。

- 或 -

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

示例

下面的代码示例连接到消息队列并将消息发送到队列。

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
   void SendMessage()
   {
      
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      
      // 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();
      }
      else
      {
         myQueue->Send( "My Message Data." );
      }

      return;
   }

};

int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Send a message to a queue.
   myNewQueue->SendMessage();
   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 a message to 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();

            return;
        }

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

            // 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();
            }
            else
            {
                myQueue.Send("My Message Data.");
            }

            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        ' 
        ' This example sends a message to a queue.
        '

        Public Shared Sub Main()

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

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

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessage()

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

            ' 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()

            Else
                myQueue.Send("My Message Data.")
            End If

            Return

        End Sub

End Class

下面的代码示例将应用程序定义的 Order 类发送到队列，然后从该队列接收消息。

注解

使用此重载将包含 obj 参数的消息发送到引用的 MessageQueue队列。发送到队列的对象可以是 Message 或任何托管对象。如果发送除以外的 Message任何对象，则对象将被序列化并插入到消息正文中。

如果使用此重载将消息发送到事务队列，则消息将发送到死信队列。如果希望消息成为包含其他消息的事务的一部分，请使用采用 MessageQueueTransaction 或 MessageQueueTransactionType 作为参数的重载。

如果在调用 Send(Object)之前未设置 Formatter 属性，格式化程序默认为 XmlMessageFormatter。

属性 DefaultPropertiesToSend 适用于除以外的 Message任何对象。例如，如果使用成员指定标签或优先级 DefaultPropertiesToSend ，则当应用程序将对象发送到队列时，这些值将应用于包含非类型的 Message 对象的任何消息。发送 Message时，为 Message 设置的属性值优先于 DefaultPropertiesToSend ，消息的 Message.Formatter 属性优先于队列的 MessageQueue.Formatter 属性。

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

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

另请参阅

适用于

Send(Object, MessageQueueTransaction)

将对象发送到此 MessageQueue 所引用的事务性队列。

public:
 void Send(System::Object ^ obj, System::Messaging::MessageQueueTransaction ^ transaction);

public void Send (object obj, System.Messaging.MessageQueueTransaction transaction);

member this.Send : obj * System.Messaging.MessageQueueTransaction -> unit

Public Sub Send (obj As Object, transaction As MessageQueueTransaction)

参数

obj: Object

要发送到队列的对象。

transaction: MessageQueueTransaction

MessageQueueTransaction 对象。

例外

ArgumentNullException

transaction 参数为 null。

MessageQueueException

尚未设置 Path 属性。

- 或 -

“消息队列”应用程序指示事务用法不正确。

- 或 -

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

示例

下面的代码示例将字符串发送到事务性队列，然后从该队列接收消息。

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

注解

使用此重载，使用由参数定义的内部事务上下文，将包含 obj 参数的消息发送到引用的transaction事务队列MessageQueue。发送到队列的对象可以是 Message 或任何托管对象。如果发送除以外的 Message任何对象，则对象将被序列化并插入到消息正文中。

如果使用此重载将消息发送到非事务性队列，则消息可能会发送到死信队列，而不会引发异常。

如果在调用 Send(Object)之前未设置 Formatter 属性，格式化程序默认为 XmlMessageFormatter。

MessageQueueTransaction 是线程单元感知，因此如果单元状态为 STA，则不能在多个线程中使用事务。 Visual Basic 将main线程的状态设置为 STA，因此必须在子例程中Main应用 MTAThreadAttribute 。否则，利用另一个线程发送事务性消息将引发 MessageQueueException 异常。使用以下片段应用 MTAThreadAttribute 。

<System.MTAThreadAttribute>
 public sub Main()

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

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

另请参阅

适用于

Send(Object, MessageQueueTransactionType)

将对象发送到此 MessageQueue 所引用的队列。

public:
 void Send(System::Object ^ obj, System::Messaging::MessageQueueTransactionType transactionType);

public void Send (object obj, System.Messaging.MessageQueueTransactionType transactionType);

member this.Send : obj * System.Messaging.MessageQueueTransactionType -> unit

Public Sub Send (obj As Object, transactionType As MessageQueueTransactionType)

参数

obj: Object

要发送到队列的对象。

transactionType: MessageQueueTransactionType

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

例外

InvalidEnumArgumentException

transactionType 参数不是 MessageQueueTransactionType 成员之一。

MessageQueueException

尚未设置 Path 属性。

- 或 -

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

示例

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

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

注解

使用此重载使用由参数定义的事务上下文，将包含 obj 参数的消息发送到引用的transactionType队列MessageQueue。如果已将外部事务上下文附加到要用于发送消息的线程，则为 transactionType 参数指定 Automatic 。指定 Single 是否要将消息作为单个内部事务发送。可以指定 None 是否要将事务性消息发送到非事务线程。

发送到队列的对象可以是 Message 或任何托管对象。如果发送除以外的 Message任何对象，则对象将被序列化并插入到消息正文中。

如果在调用 Send(Object)之前未设置 Formatter 属性，格式化程序默认为 XmlMessageFormatter。

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

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

另请参阅

适用于

Send(Object, String)

将对象发送到此 MessageQueue 引用的非事务性队列，并指定消息的标签。

public:
 void Send(System::Object ^ obj, System::String ^ label);

public void Send (object obj, string label);

member this.Send : obj * string -> unit

Public Sub Send (obj As Object, label As String)

参数

obj: Object

要发送到队列的对象。

label: String

消息的标签。

例外

ArgumentNullException

label 参数为 null。

MessageQueueException

尚未设置 Path 属性。

- 或 -

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

示例

以下代码示例演示了 Send(Object, String) 的用法。


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

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

// Send the message.
queue->Send(msg, "Example Message Label");

queue->Close();


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

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

// Send the message.
queue.Send(msg, "Example Message Label");

注解

使用此重载将包含 obj 参数的消息发送到引用 MessageQueue的队列。使用此重载，可以指定标识消息的字符串标签。发送到队列的对象可以是 Message、结构、数据对象或任何托管对象。如果发送除以外的 Message任何对象，则会序列化对象并将其插入到消息正文中。

消息标签不同于消息队列标签，但两者都依赖于应用程序，并且对消息队列没有继承意义。

如果使用此重载将消息发送到事务队列，则会将消息发送到死信队列。如果希望消息成为包含其他消息的事务的一部分，请使用采用 MessageQueueTransaction 或 MessageQueueTransactionType 作为参数的重载。

在 Path 发送消息之前，必须指定此 MessageQueue 实例的属性。如果在调用 Send(Object)之前未设置 Formatter 属性，则格式化程序默认为 XmlMessageFormatter。

属性 DefaultPropertiesToSend 适用于除以外的 Message任何对象。例如，如果使用成员指定标签或优先级 DefaultPropertiesToSend ，则当应用程序将对象发送到队列时，这些值将应用于包含非类型 Message 对象的任何消息。发送时， Message为 Message 设置的属性值优先于 DefaultPropertiesToSend ，消息的 Message.Formatter 属性优先于队列的 MessageQueue.Formatter 属性。

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

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

另请参阅

适用于

Send(Object, String, MessageQueueTransaction)

将对象发送到此 MessageQueue 引用的事务性队列中，并指定该消息的标签。

public:
 void Send(System::Object ^ obj, System::String ^ label, System::Messaging::MessageQueueTransaction ^ transaction);

public void Send (object obj, string label, System.Messaging.MessageQueueTransaction transaction);

member this.Send : obj * string * System.Messaging.MessageQueueTransaction -> unit

Public Sub Send (obj As Object, label As String, transaction As MessageQueueTransaction)

参数

obj: Object

要发送到队列的对象。

label: String

消息的标签。

transaction: MessageQueueTransaction

MessageQueueTransaction 对象。

例外

ArgumentNullException

label 参数为 null。

- 或 -

transaction 参数为 null。

MessageQueueException

尚未设置 Path 属性。

- 或 -

“消息队列”应用程序指示了不正确的事务用法。

- 或 -

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

示例

以下代码示例演示了 Send(Object, String, MessageQueueTransaction) 的用法。


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

// Create a message queuing transaction.
MessageQueueTransaction^ transaction = gcnew MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction->Begin();

    // Send the message to the queue.
    queue->Send(msg, "Example Message Label", transaction);

    // Commit the transaction.
    transaction->Commit();
}
catch (Exception^ ex)
{
    // Cancel the transaction.
    transaction->Abort();

    // Propagate the exception.
    throw ex;
}
finally
{
    // Dispose of the transaction object.
    delete transaction;
    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");

// Create a message queuing transaction.
MessageQueueTransaction transaction = new MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction.Begin();

    // Send the message to the queue.
    queue.Send(msg, "Example Message Label", transaction);

    // Commit the transaction.
    transaction.Commit();
}
catch(System.Exception e)
{
    // Cancel the transaction.
    transaction.Abort();

    // Propagate the exception.
    throw e;
}
finally
{
    // Dispose of the transaction object.
    transaction.Dispose();
}

注解

使用此重载，可以使用参数定义的内部事务上下文，将包含 obj 参数的消息发送到由 MessageQueue引用的 transaction 事务队列。使用此重载，可以指定标识消息的字符串标签。发送到队列的对象可以是 Message、结构、数据对象或任何托管对象。如果发送除以外的 Message任何对象，则会序列化对象并将其插入到消息正文中。

消息标签不同于消息队列标签，但两者都依赖于应用程序，并且对消息队列没有继承意义。

如果使用此重载将消息发送到非事务性队列，则消息可能会发送到死信队列，而不会引发异常。

如果在调用 Send(Object)之前未设置 Formatter 属性，则格式化程序默认为 XmlMessageFormatter。

属性 DefaultPropertiesToSend 适用于除以外的 Message任何对象。例如，如果使用成员指定标签或优先级 DefaultPropertiesToSend ，则当应用程序将对象发送到队列时，这些值将应用于包含非类型 Message 对象的任何消息。发送时， Message为 Message 优先设置的属性值优先于 DefaultPropertiesToSend ，消息的 Message.Formatter 属性优先于队列的 MessageQueue.Formatter 属性

MessageQueueTransaction 是线程单元感知，因此，如果单元状态为 STA，则不能在多个线程中使用事务。 Visual Basic 将main线程的状态设置为 STA，因此必须在子例程中Main应用 MTAThreadAttribute 。否则，利用另一个线程发送事务性消息将引发 MessageQueueException 异常。使用以下片段应用 MTAThreadAttribute 。

<System.MTAThreadAttribute>
 public sub Main()

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

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

另请参阅

适用于

Send(Object, String, MessageQueueTransactionType)

将对象发送到此 MessageQueue 引用的队列中，并指定该消息的标签。

public:
 void Send(System::Object ^ obj, System::String ^ label, System::Messaging::MessageQueueTransactionType transactionType);

public void Send (object obj, string label, System.Messaging.MessageQueueTransactionType transactionType);

member this.Send : obj * string * System.Messaging.MessageQueueTransactionType -> unit

Public Sub Send (obj As Object, label As String, transactionType As MessageQueueTransactionType)

参数

obj: Object

要发送到队列的对象。

label: String

消息的标签。

transactionType: MessageQueueTransactionType

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

例外

ArgumentNullException

label 参数为 null。

MessageQueueTransaction

“消息队列”应用程序指示了不正确的事务用法。

InvalidEnumArgumentException

transactionType 参数不是 MessageQueueTransactionType 成员之一。

MessageQueueException

尚未设置 Path 属性。

- 或 -

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

示例

以下代码示例演示了 Send(Object, String, 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, "Example Message Label",
    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, "Example Message Label",
    MessageQueueTransactionType.Single);

注解

使用此重载，可以使用参数定义的事务上下文，将包含 obj 参数的消息发送到引用的transactionType队列MessageQueue。如果已将外部事务上下文附加到要用于发送消息的线程，请为 transactionType 参数指定 Automatic 。指定 Single 是否要将消息作为单个内部事务发送。可以指定 None 是否要将事务性消息发送到非事务线程。

发送到队列的对象可以是 Message 或任何托管对象。如果发送除以外的 Message任何对象，则会序列化对象并将其插入到消息正文中。使用此重载，可以指定标识消息的字符串标签。

消息标签不同于消息队列标签，但两者都依赖于应用程序，并且对消息队列没有继承意义。

如果在调用 Send(Object)之前未设置 Formatter 属性，则格式化程序默认为 XmlMessageFormatter。

属性 DefaultPropertiesToSend 适用于除以外的 Message任何对象。例如，如果使用成员指定标签或优先级 DefaultPropertiesToSend ，则当应用程序将对象发送到队列时，这些值将应用于包含非类型 Message 对象的任何消息。发送时， Message为 Message 设置的属性值优先于 DefaultPropertiesToSend，消息的 Message.Formatter 属性优先于队列的 MessageQueue.Formatter 属性。

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

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

另请参阅

适用于

通过

MessageQueue.Send 方法

定义

重载

Send(Object)

参数

例外

示例

注解

另请参阅

适用于

Send(Object, MessageQueueTransaction)

参数

例外

示例

注解

另请参阅

适用于

Send(Object, MessageQueueTransactionType)

参数

例外

示例

注解

另请参阅

适用于

Send(Object, String)

参数

例外

示例

注解

另请参阅

适用于

Send(Object, String, MessageQueueTransaction)

参数

例外

示例

注解

另请参阅

适用于

Send(Object, String, MessageQueueTransactionType)

参数

例外

示例

注解

另请参阅

适用于

其他资源