MessageQueue.Send Methode

Definition

Namespace:

System.Messaging

Assembly:

System.Messaging.dll

Sendet ein Objekt an eine Warteschlange.

Überlädt

Send(Object)	Sendet ein Objekt an die nicht transaktionale Warteschlange, auf die diese MessageQueue verweist.
Send(Object, MessageQueueTransaction)	Sendet ein Objekt an die transaktionale Warteschlange, auf die diese MessageQueue verweist.
Send(Object, MessageQueueTransactionType)	Sendet ein Objekt an die Warteschlange, auf die diese MessageQueue verweist.
Send(Object, String)	Sendet ein Objekt an die nicht transaktionale Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.
Send(Object, String, MessageQueueTransaction)	Sendet ein Objekt an die transaktionale Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.
Send(Object, String, MessageQueueTransactionType)	Sendet ein Objekt an die Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.

Send(Object)

Sendet ein Objekt an die nicht transaktionale Warteschlange, auf die diese MessageQueue verweist.

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

public void Send (object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

Parameter

obj

Object

Das an die Warteschlange zu sendende Objekt.

Ausnahmen

MessageQueueException

Die Path-Eigenschaft wurde nicht festgelegt.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird eine Verbindung mit einer Nachrichtenwarteschlange hergestellt und eine Nachricht an die Warteschlange gesendet.

#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

Das folgende Codebeispiel sendet eine anwendungsdefinierte Order Klasse an eine Warteschlange und empfängt dann eine Nachricht von dieser Warteschlange.

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht mit dem obj Parameter an die Warteschlange zu senden, auf die MessageQueuevon verwiesen wird. Das Objekt, das Sie an die Warteschlange senden, kann ein oder ein Message beliebiges verwaltetes Objekt sein. Wenn Sie ein anderes Objekt als ein Messagesenden, wird das Objekt serialisiert und in den Textkörper der Nachricht eingefügt.

Wenn Sie diese Überladung verwenden, um eine Nachricht an eine Transaktionswarteschlange zu senden, wird die Nachricht an die Warteschlange für unzustellbare Nachrichten gesendet. Wenn die Nachricht Teil einer Transaktion sein soll, die andere Nachrichten enthält, verwenden Sie eine Überladung, die einen MessageQueueTransaction oder MessageQueueTransactionType als Parameter akzeptiert.

Wenn Sie die Formatter Eigenschaft vor dem Aufrufen Send(Object)nicht festlegen, wird standardmäßig der Formatierer auf festgelegt XmlMessageFormatter.

Die DefaultPropertiesToSend -Eigenschaft gilt für jedes andere Objekt als ein Message. Wenn Sie beispielsweise eine Bezeichnung oder Eine Priorität mithilfe des DefaultPropertiesToSend Members angeben, gelten diese Werte für jede Nachricht, die ein Objekt enthält, das nicht vom Typ Message ist, wenn Ihre Anwendung es an die Warteschlange sendet. Beim Senden eines Messagehaben die für den Message festgelegten Eigenschaftswerte Vorrang, DefaultPropertiesToSend und die Eigenschaft der Nachricht Message.Formatter hat Vorrang vor der Eigenschaft der Warteschlange MessageQueue.Formatter .

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und des direkten Formats	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

• DefaultPropertiesToSend
• Message
• Path
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

Send(Object, MessageQueueTransaction)

Sendet ein Objekt an die transaktionale Warteschlange, auf die diese MessageQueue verweist.

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)

Parameter

obj

Object

Das an die Warteschlange zu sendende Objekt.

transaction

MessageQueueTransaction

Das MessageQueueTransaction-Objekt.

Ausnahmen

ArgumentNullException

Der transaction-Parameter ist null.

MessageQueueException

Die Path-Eigenschaft wurde nicht festgelegt.

- oder -

Die Message Queuing-Anwendung hat eine falsche Verwendung der Transaktion gemeldet.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Das folgende Codebeispiel sendet eine Zeichenfolge an eine Transaktionswarteschlange und empfängt dann eine Nachricht von dieser Warteschlange.

#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

Hinweise

Verwenden Sie diese Überladung, um mithilfe eines internen Transaktionskontexts, der durch obj den -Parameter definiert wird, eine Nachricht mit dem Parameter an die Transaktionswarteschlange zu senden, auf die MessageQueuetransaction verwiesen wird. Das Objekt, das Sie an die Warteschlange senden, kann ein oder ein Message beliebiges verwaltetes Objekt sein. Wenn Sie ein anderes Objekt als ein Messagesenden, wird das Objekt serialisiert und in den Textkörper der Nachricht eingefügt.

Wenn Sie diese Überladung verwenden, um eine Nachricht an eine nicht transaktionale Warteschlange zu senden, wird die Nachricht möglicherweise an die Warteschlange für unzustellbare Nachrichten gesendet, ohne eine Ausnahme auszulösen.

Wenn Sie die Formatter Eigenschaft vor dem Aufrufen Send(Object)nicht festlegen, wird standardmäßig der Formatierer auf festgelegt XmlMessageFormatter.

Die DefaultPropertiesToSend -Eigenschaft gilt für jedes andere Objekt als ein Message. Wenn Sie beispielsweise eine Bezeichnung oder Eine Priorität mithilfe des DefaultPropertiesToSend Members angeben, gelten diese Werte für jede Nachricht, die ein Objekt enthält, das nicht vom Typ Message ist, wenn Ihre Anwendung es an die Warteschlange sendet. Beim Senden eines Messagehaben die für den Message festgelegten Eigenschaftswerte Vorrang, DefaultPropertiesToSend und die Eigenschaft der Nachricht Message.Formatter hat Vorrang vor der Eigenschaft der Warteschlange MessageQueue.Formatter .

MessageQueueTransaction ist threading apartment-fähig. Wenn Ihr Apartmentstatus also lautet STA, können Sie die Transaktion nicht in mehreren Threads verwenden. Visual Basic legt den Zustand des Standard Threads auf festSTA, sodass Sie den MTAThreadAttribute in der Main Unterroutine anwenden müssen. Andernfalls wird durch das Senden einer Transaktionsmeldung mithilfe eines anderen Threads eine MessageQueueException-Ausnahme ausgelöst. Verwenden Sie das MTAThreadAttribute folgende Fragment.

<System.MTAThreadAttribute>
 public sub Main()

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und des direkten Formats	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

• DefaultPropertiesToSend
• Message
• MessageQueueTransaction
• Transactional
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

Send(Object, MessageQueueTransactionType)

Sendet ein Objekt an die Warteschlange, auf die diese MessageQueue verweist.

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)

Parameter

obj

Object

Das an die Warteschlange zu sendende Objekt.

transactionType

MessageQueueTransactionType

Einer der MessageQueueTransactionType-Werte, der den Typ des Transaktionskontexts beschreibt, der der Meldung zugeordnet werden soll.

Ausnahmen

InvalidEnumArgumentException

Der transactionType-Parameter ist keiner der MessageQueueTransactionType-Member.

MessageQueueException

Die Path-Eigenschaft wurde nicht festgelegt.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung von 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);

Hinweise

Verwenden Sie diese Überladung, um mithilfe eines durch den Parameter definierten Transaktionskontexts eine Nachricht mit dem obj Parameter an die Warteschlange zu senden, auf die MessageQueuetransactionType verwiesen wird. Geben Sie Automatic für den transactionType Parameter an, wenn bereits ein externer Transaktionskontext an den Thread angefügt ist, den Sie zum Senden der Nachricht verwenden möchten. Geben Sie an Single , ob Sie die Nachricht als einzelne interne Transaktion senden möchten. Sie können angeben None , ob Sie eine Transaktionsnachricht an einen nicht transaktionalen Thread senden möchten.

Das Objekt, das Sie an die Warteschlange senden, kann ein oder ein Message beliebiges verwaltetes Objekt sein. Wenn Sie ein anderes Objekt als ein Messagesenden, wird das Objekt serialisiert und in den Textkörper der Nachricht eingefügt.

Wenn Sie die Formatter Eigenschaft vor dem Aufrufen Send(Object)nicht festlegen, wird standardmäßig der Formatierer auf festgelegt XmlMessageFormatter.

Die DefaultPropertiesToSend -Eigenschaft gilt für jedes andere Objekt als ein Message. Wenn Sie beispielsweise eine Bezeichnung oder Eine Priorität mithilfe des DefaultPropertiesToSend Members angeben, gelten diese Werte für jede Nachricht, die ein Objekt enthält, das nicht vom Typ Message ist, wenn Ihre Anwendung es an die Warteschlange sendet. Beim Senden eines Messagehaben die für den Message festgelegten Eigenschaftswerte Vorrang, DefaultPropertiesToSend und die Eigenschaft der Nachricht Message.Formatter hat Vorrang vor der Eigenschaft der Warteschlange MessageQueue.Formatter .

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und des direkten Formats	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

• MessageQueueTransactionType
• DefaultPropertiesToSend
• Message
• Transactional
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

Send(Object, String)

Sendet ein Objekt an die nicht transaktionale Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.

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)

Parameter

obj

Object

Das an die Warteschlange zu sendende Objekt.

label

String

Die Meldungsbezeichnung.

Ausnahmen

ArgumentNullException

Der label-Parameter ist null.

MessageQueueException

Die Path-Eigenschaft wurde nicht festgelegt.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung von 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");

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht mit dem obj Parameter an die Warteschlange zu senden, auf die MessageQueuevon verwiesen wird. Mit dieser Überladung können Sie die Zeichenfolgenbezeichnung angeben, die die Nachricht identifiziert. Das Objekt, das Sie an die Warteschlange senden, kann eine Message-Struktur, ein Datenobjekt oder ein beliebiges verwaltetes Objekt sein. Wenn Sie ein anderes Objekt als ein Messagesenden, wird das Objekt serialisiert und in den Textkörper der Nachricht eingefügt.

Die Nachrichtenbezeichnung unterscheidet sich von der Nachrichtenwarteschlangenbezeichnung, aber beide sind anwendungsabhängig und haben keine vererbte Bedeutung für Message Queuing.

Wenn Sie diese Überladung verwenden, um eine Nachricht an eine Transaktionswarteschlange zu senden, wird die Nachricht an die Warteschlange für unzustellbare Nachrichten gesendet. Wenn die Nachricht Teil einer Transaktion sein soll, die andere Nachrichten enthält, verwenden Sie eine Überladung, die einen MessageQueueTransaction oder MessageQueueTransactionType als Parameter akzeptiert.

Die Path Eigenschaft für diese MessageQueue instance muss angegeben werden, bevor Sie die Nachricht senden. Wenn Sie die Formatter Eigenschaft vor dem Aufrufen Send(Object)nicht festlegen, wird standardmäßig der Formatierer auf festgelegt XmlMessageFormatter.

Die DefaultPropertiesToSend -Eigenschaft gilt für jedes andere Objekt als ein Message. Wenn Sie beispielsweise eine Bezeichnung oder Eine Priorität mithilfe des DefaultPropertiesToSend Members angeben, gelten diese Werte für jede Nachricht, die ein Objekt enthält, das nicht vom Typ Message ist, wenn Ihre Anwendung es an die Warteschlange sendet. Beim Senden eines Messagehaben die für den Message festgelegten Eigenschaftswerte Vorrang, DefaultPropertiesToSend und die Eigenschaft der Nachricht Message.Formatter hat Vorrang vor der Eigenschaft der Warteschlange MessageQueue.Formatter .

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und des direkten Formats	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

• DefaultPropertiesToSend
• Message
• Label
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

Send(Object, String, MessageQueueTransaction)

Sendet ein Objekt an die transaktionale Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.

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)

Parameter

obj

Object

Das an die Warteschlange zu sendende Objekt.

label

String

Die Meldungsbezeichnung.

transaction

MessageQueueTransaction

Das MessageQueueTransaction-Objekt.

Ausnahmen

ArgumentNullException

Der label-Parameter ist null.

- oder -

Der transaction-Parameter ist null.

MessageQueueException

Die Path-Eigenschaft wurde nicht festgelegt.

- oder -

Die Message Queuing-Anwendung hat eine falsche Verwendung der Transaktion gemeldet.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung von 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();
}

Hinweise

Verwenden Sie diese Überladung, um mithilfe eines internen Transaktionskontexts, der durch obj den -Parameter definiert wird, eine Nachricht mit dem Parameter an die Transaktionswarteschlange zu senden, auf die MessageQueuetransaction verwiesen wird. Mit dieser Überladung können Sie die Zeichenfolgenbezeichnung angeben, die die Nachricht identifiziert. Das Objekt, das Sie an die Warteschlange senden, kann eine Message-Struktur, ein Datenobjekt oder ein beliebiges verwaltetes Objekt sein. Wenn Sie ein anderes Objekt als ein Messagesenden, wird das Objekt serialisiert und in den Textkörper der Nachricht eingefügt.

Die Nachrichtenbezeichnung unterscheidet sich von der Nachrichtenwarteschlangenbezeichnung, aber beide sind anwendungsabhängig und haben keine vererbte Bedeutung für Message Queuing.

Wenn Sie diese Überladung verwenden, um eine Nachricht an eine nicht transaktionale Warteschlange zu senden, wird die Nachricht möglicherweise an die Warteschlange für unzustellbare Nachrichten gesendet, ohne eine Ausnahme auszulösen.

Wenn Sie die Formatter Eigenschaft vor dem Aufrufen Send(Object)nicht festlegen, wird standardmäßig der Formatierer auf festgelegt XmlMessageFormatter.

Die DefaultPropertiesToSend -Eigenschaft gilt für jedes andere Objekt als ein Message. Wenn Sie beispielsweise eine Bezeichnung oder Eine Priorität mithilfe des DefaultPropertiesToSend Members angeben, gelten diese Werte für jede Nachricht, die ein Objekt enthält, das nicht vom Typ Message ist, wenn Ihre Anwendung es an die Warteschlange sendet. Beim Senden eines Messagehaben die für den Message festgelegten Eigenschaftswerte Vorrang, DefaultPropertiesToSend und die Eigenschaft der Nachricht Message.Formatter hat Vorrang vor der Eigenschaft der Warteschlange MessageQueue.Formatter .

MessageQueueTransaction ist threading apartment-fähig. Wenn Ihr Apartmentstatus also lautet STA, können Sie die Transaktion nicht in mehreren Threads verwenden. Visual Basic legt den Zustand des Standard Threads auf festSTA, sodass Sie den MTAThreadAttribute in der Main Unterroutine anwenden müssen. Andernfalls wird durch das Senden einer Transaktionsmeldung mithilfe eines anderen Threads eine MessageQueueException-Ausnahme ausgelöst. Verwenden Sie das MTAThreadAttribute folgende Fragment.

<System.MTAThreadAttribute>
 public sub Main()

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und des direkten Formats	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

• DefaultPropertiesToSend
• Message
• MessageQueueTransaction
• Transactional
• Label
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

Send(Object, String, MessageQueueTransactionType)

Sendet ein Objekt an die Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.

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)

Parameter

obj

Object

Das an die Warteschlange zu sendende Objekt.

label

String

Die Meldungsbezeichnung.

transactionType

MessageQueueTransactionType

Einer der MessageQueueTransactionType-Werte, der den Typ des Transaktionskontexts beschreibt, der der Meldung zugeordnet werden soll.

Ausnahmen

ArgumentNullException

Der label-Parameter ist null.

MessageQueueTransaction

Die Message Queuing-Anwendung hat eine falsche Verwendung der Transaktion gemeldet.

InvalidEnumArgumentException

Der transactionType-Parameter ist keiner der MessageQueueTransactionType-Member.

MessageQueueException

Die Path-Eigenschaft wurde nicht festgelegt.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung von 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);

Hinweise

Verwenden Sie diese Überladung, um mithilfe eines durch den Parameter definierten Transaktionskontexts eine Nachricht mit dem obj Parameter an die Warteschlange zu senden, auf die MessageQueuetransactionType verwiesen wird. Geben Sie Automatic für den transactionType Parameter an, wenn bereits ein externer Transaktionskontext an den Thread angefügt ist, den Sie zum Senden der Nachricht verwenden möchten. Geben Sie an Single , ob Sie die Nachricht als einzelne interne Transaktion senden möchten. Sie können angeben None , ob Sie eine Transaktionsnachricht an einen nicht transaktionalen Thread senden möchten.

Das Objekt, das Sie an die Warteschlange senden, kann ein oder ein Message beliebiges verwaltetes Objekt sein. Wenn Sie ein anderes Objekt als ein Messagesenden, wird das Objekt serialisiert und in den Textkörper der Nachricht eingefügt. Mit dieser Überladung können Sie die Zeichenfolgenbezeichnung angeben, die die Nachricht identifiziert.

Die Nachrichtenbezeichnung unterscheidet sich von der Nachrichtenwarteschlangenbezeichnung, aber beide sind anwendungsabhängig und haben keine vererbte Bedeutung für Message Queuing.

Wenn Sie die Formatter Eigenschaft vor dem Aufrufen Send(Object)nicht festlegen, wird standardmäßig der Formatierer auf festgelegt XmlMessageFormatter.

Die DefaultPropertiesToSend -Eigenschaft gilt für jedes andere Objekt als ein Message. Wenn Sie beispielsweise eine Bezeichnung oder Eine Priorität mithilfe des DefaultPropertiesToSend Members angeben, gelten diese Werte für jede Nachricht, die ein Objekt enthält, das nicht vom Typ Message ist, wenn Ihre Anwendung es an die Warteschlange sendet. Beim Senden eines Messagehaben die für den Message festgelegten Eigenschaftswerte Vorrang vor DefaultPropertiesToSend, und die Eigenschaft der Nachricht Message.Formatter hat Vorrang vor der Eigenschaft der Warteschlange MessageQueue.Formatter .

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokalem Computer	Ja
Name des lokalen Computers und des direkten Formats	Ja
Remotecomputer	Nein
Name des Remotecomputers und des direkten Formats	Ja

Weitere Informationen

• MessageQueueTransactionType
• DefaultPropertiesToSend
• Message
• Transactional
• Label
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()