MessageQueue.Send Methode

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

public void Send(object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

Parameters

Uitzonderingen

Voorbeelden

Het volgende codevoorbeeld maakt verbinding met een berichtenwachtrij en verzendt een bericht naar de wachtrij.

#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 )
      {
         
         // 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)
            {
                // 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

In het volgende codevoorbeeld wordt een door de toepassing gedefinieerde Order klasse naar een wachtrij verzonden en wordt vervolgens een bericht van die wachtrij ontvangen.

Opmerkingen

Gebruik deze overbelasting om een bericht te verzenden dat de obj parameter bevat naar de wachtrij waarnaar wordt verwezen door de MessageQueue. Het object dat u naar de wachtrij verzendt, kan een Message of elk beheerd object zijn. Als u een ander object dan een Messageobject verzendt, wordt het object geserialiseerd en ingevoegd in de hoofdtekst van het bericht.

Als u deze overbelasting gebruikt om een bericht naar een transactionele wachtrij te verzenden, wordt het bericht verzonden naar de wachtrij met dode letters. Als u wilt dat het bericht deel uitmaakt van een transactie die andere berichten bevat, gebruikt u een overbelasting die een MessageQueueTransaction of MessageQueueTransactionType als parameter gebruikt.

Als u de Formatter eigenschap niet instelt voordat u aanroept Send(Object), wordt de notatie standaard ingesteld op de XmlMessageFormatter.

De DefaultPropertiesToSend eigenschap is van toepassing op een ander object dan een Message. Als u bijvoorbeeld een label of prioriteit opgeeft met behulp van het DefaultPropertiesToSend lid, zijn deze waarden van toepassing op elk bericht dat een object bevat dat niet van het type Message is wanneer uw toepassing het naar de wachtrij verzendt. Wanneer u een Messagebericht verzendt, hebben de eigenschapswaarden die zijn ingesteld voor de Message prioriteit DefaultPropertiesToSend en heeft de eigenschap van Message.Formatter het bericht voorrang op de eigenschap van MessageQueue.Formatter de wachtrij.

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

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

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)

Parameters

Uitzonderingen

Voorbeelden

Het volgende codevoorbeeld verzendt een tekenreeks naar een transactionele wachtrij en ontvangt vervolgens een bericht van die wachtrij.

#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 )
      {
         // 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)
            {
                // 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

Opmerkingen

Gebruik deze overbelasting om een bericht te verzenden dat de obj parameter bevat naar de transactionele wachtrij waarnaar wordt verwezen door de MessageQueue, met behulp van een interne transactiecontext die is gedefinieerd door de transaction parameter. Het object dat u naar de wachtrij verzendt, kan een Message of elk beheerd object zijn. Als u een ander object dan een Messageobject verzendt, wordt het object geserialiseerd en ingevoegd in de hoofdtekst van het bericht.

Als u deze overbelasting gebruikt om een bericht naar een niet-transactionele wachtrij te verzenden, kan het bericht worden verzonden naar de wachtrij met dode letters zonder een uitzondering te genereren.

Als u de Formatter eigenschap niet instelt voordat u aanroept Send(Object), wordt de notatie standaard ingesteld op de XmlMessageFormatter.

De DefaultPropertiesToSend eigenschap is van toepassing op een ander object dan een Message. Als u bijvoorbeeld een label of prioriteit opgeeft met behulp van het DefaultPropertiesToSend lid, zijn deze waarden van toepassing op elk bericht dat een object bevat dat niet van het type Message is wanneer uw toepassing het naar de wachtrij verzendt. Wanneer u een Messagebericht verzendt, hebben de eigenschapswaarden die zijn ingesteld voor de Message prioriteit DefaultPropertiesToSend en heeft de eigenschap van Message.Formatter het bericht voorrang op de eigenschap van MessageQueue.Formatter de wachtrij.

MessageQueueTransaction is threading appartement bewust, dus als uw appartementsstatus is STA, kunt u de transactie niet gebruiken in meerdere threads. Visual Basic stelt de status van de hoofdthread in op STA, dus moet u de MTAThreadAttribute toepassen in de subroutine Main. Anders genereert het verzenden van een transactioneel bericht met een andere thread een MessageQueueException uitzondering. U past het MTAThreadAttribute toe met behulp van het volgende fragment.

<System.MTAThreadAttribute>
 public sub Main()

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

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

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)

Parameters

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u het gebruik van 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);

Opmerkingen

Gebruik deze overbelasting om een bericht te verzenden dat de obj parameter bevat naar de wachtrij waarnaar wordt verwezen door de MessageQueue, met behulp van een transactiecontext die is gedefinieerd door de transactionType parameter. Geef Automatic op voor de transactionType parameter als er al een externe transactiecontext is gekoppeld aan de thread die u wilt gebruiken om het bericht te verzenden. Geef op Single of u het bericht wilt verzenden als één interne transactie. U kunt opgeven None of u een transactioneel bericht wilt verzenden naar een niet-transactionele thread.

Het object dat u naar de wachtrij verzendt, kan een Message of elk beheerd object zijn. Als u een ander object dan een Messageobject verzendt, wordt het object geserialiseerd en ingevoegd in de hoofdtekst van het bericht.

Als u de Formatter eigenschap niet instelt voordat u aanroept Send(Object), wordt de notatie standaard ingesteld op de XmlMessageFormatter.

De DefaultPropertiesToSend eigenschap is van toepassing op een ander object dan een Message. Als u bijvoorbeeld een label of prioriteit opgeeft met behulp van het DefaultPropertiesToSend lid, zijn deze waarden van toepassing op elk bericht dat een object bevat dat niet van het type Message is wanneer uw toepassing het naar de wachtrij verzendt. Wanneer u een Messagebericht verzendt, hebben de eigenschapswaarden die zijn ingesteld voor de Message prioriteit DefaultPropertiesToSend en heeft de eigenschap van Message.Formatter het bericht voorrang op de eigenschap van MessageQueue.Formatter de wachtrij.

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

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

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)

Parameters

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u het gebruik van 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");

Opmerkingen

Gebruik deze overbelasting om een bericht te verzenden dat de obj parameter bevat naar de wachtrij waarnaar wordt verwezen door de MessageQueue. Met deze overbelasting kunt u het tekenreekslabel opgeven waarmee het bericht wordt geïdentificeerd. Het object dat u naar de wachtrij verzendt, kan een Messagestructuur, een gegevensobject of een beheerd object zijn. Als u een ander object dan een Messageobject verzendt, wordt het object geserialiseerd en ingevoegd in de hoofdtekst van het bericht.

Het berichtlabel verschilt van het label van de berichtenwachtrij, maar beide zijn toepassingsafhankelijk en hebben geen betekenis voor Message Queuing.

Als u deze overbelasting gebruikt om een bericht naar een transactionele wachtrij te verzenden, wordt het bericht verzonden naar de wachtrij met dode letters. Als u wilt dat het bericht deel uitmaakt van een transactie die andere berichten bevat, gebruikt u een overbelasting die een MessageQueueTransaction of MessageQueueTransactionType als parameter gebruikt.

De Path eigenschap voor dit MessageQueue exemplaar moet worden opgegeven voordat u het bericht verzendt. Als u de Formatter eigenschap niet instelt voordat u aanroept Send(Object), wordt de notatie standaard ingesteld op de XmlMessageFormatter.

De DefaultPropertiesToSend eigenschap is van toepassing op een ander object dan een Message. Als u bijvoorbeeld een label of prioriteit opgeeft met behulp van het DefaultPropertiesToSend lid, zijn deze waarden van toepassing op elk bericht dat een object bevat dat niet van het type Message is wanneer uw toepassing het naar de wachtrij verzendt. Wanneer u een Messagebericht verzendt, hebben de eigenschapswaarden die zijn ingesteld voor de Message prioriteit DefaultPropertiesToSend en heeft de eigenschap van Message.Formatter het bericht voorrang op de eigenschap van MessageQueue.Formatter de wachtrij.

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

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

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)

Parameters

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u het gebruik van 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();
}

Opmerkingen

Gebruik deze overbelasting om een bericht te verzenden dat de obj parameter bevat naar de transactionele wachtrij waarnaar wordt verwezen door de MessageQueue, met behulp van een interne transactiecontext die is gedefinieerd door de transaction parameter. Met deze overbelasting kunt u het tekenreekslabel opgeven waarmee het bericht wordt geïdentificeerd. Het object dat u naar de wachtrij verzendt, kan een Messagestructuur, een gegevensobject of een beheerd object zijn. Als u een ander object dan een Messageobject verzendt, wordt het object geserialiseerd en ingevoegd in de hoofdtekst van het bericht.

Het berichtlabel verschilt van het label van de berichtenwachtrij, maar beide zijn toepassingsafhankelijk en hebben geen betekenis voor Message Queuing.

Als u deze overbelasting gebruikt om een bericht naar een niet-transactionele wachtrij te verzenden, kan het bericht worden verzonden naar de wachtrij met dode letters zonder een uitzondering te genereren.

Als u de Formatter eigenschap niet instelt voordat u aanroept Send(Object), wordt de notatie standaard ingesteld op de XmlMessageFormatter.

De DefaultPropertiesToSend eigenschap is van toepassing op een ander object dan een Message. Als u bijvoorbeeld een label of prioriteit opgeeft met behulp van het DefaultPropertiesToSend lid, zijn deze waarden van toepassing op elk bericht dat een object bevat dat niet van het type Message is wanneer uw toepassing het naar de wachtrij verzendt. Bij het verzenden van een Message, hebben de eigenschapswaarden die zijn ingesteld voor de Message prioriteit DefaultPropertiesToSend en heeft de eigenschap van Message.Formatter het bericht voorrang op de eigenschap van MessageQueue.Formatter de wachtrij

MessageQueueTransaction is threading appartement bewust, dus als uw appartementsstatus is STA, kunt u de transactie niet gebruiken in meerdere threads. Visual Basic stelt de status van de hoofdthread in op STA, dus moet u de MTAThreadAttribute toepassen in de subroutine Main. Anders genereert het verzenden van een transactioneel bericht met een andere thread een MessageQueueException uitzondering. U past het MTAThreadAttribute toe met behulp van het volgende fragment.

<System.MTAThreadAttribute>
 public sub Main()

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

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

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)

Parameters

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u het gebruik van 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);

Opmerkingen

Gebruik deze overbelasting om een bericht te verzenden dat de obj parameter bevat naar de wachtrij waarnaar wordt verwezen door de MessageQueue, met behulp van een transactiecontext die is gedefinieerd door de transactionType parameter. Geef Automatic op voor de transactionType parameter als er al een externe transactiecontext is gekoppeld aan de thread die u wilt gebruiken om het bericht te verzenden. Geef op Single of u het bericht wilt verzenden als één interne transactie. U kunt opgeven None of u een transactioneel bericht wilt verzenden naar een niet-transactionele thread.

Het object dat u naar de wachtrij verzendt, kan een Message of elk beheerd object zijn. Als u een ander object dan een Messageobject verzendt, wordt het object geserialiseerd en ingevoegd in de hoofdtekst van het bericht. Met deze overbelasting kunt u het tekenreekslabel opgeven waarmee het bericht wordt geïdentificeerd.

Het berichtlabel verschilt van het label van de berichtenwachtrij, maar beide zijn toepassingsafhankelijk en hebben geen betekenis voor Message Queuing.

Als u de Formatter eigenschap niet instelt voordat u aanroept Send(Object), wordt de notatie standaard ingesteld op de XmlMessageFormatter.

De DefaultPropertiesToSend eigenschap is van toepassing op een ander object dan een Message. Als u bijvoorbeeld een label of prioriteit opgeeft met behulp van het DefaultPropertiesToSend lid, zijn deze waarden van toepassing op elk bericht dat een object bevat dat niet van het type Message is wanneer uw toepassing het naar de wachtrij verzendt. Bij het verzenden van een Message, hebben de eigenschapswaarden die zijn ingesteld voor de Message prioriteit DefaultPropertiesToSenden heeft de eigenschap van Message.Formatter het bericht voorrang op de eigenschap van MessageQueue.Formatter de wachtrij.

In de volgende tabel ziet u of deze methode beschikbaar is in verschillende werkgroepmodi.

Werkgroepmodus	Available
Lokale computer	Ja
Naam van lokale computer en directe indeling	Ja
Externe computer	No
Naam van externe computer en directe indeling	Ja

Zie ook

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