MessageQueue.Send Metod

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

public void Send(object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

Parametrar

Undantag

Exempel

Följande kodexempel ansluter till en meddelandekö och skickar ett meddelande till kön.

#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

Följande kodexempel skickar en programdefinierad Order klass till en kö och tar sedan emot ett meddelande från kön.

Kommentarer

Använd den här överlagringen för att skicka ett meddelande som innehåller parametern obj till kön som refereras av MessageQueue. Objektet som du skickar till kön kan vara ett Message eller ett hanterat objekt. Om du skickar något annat objekt än ett Messageserialiseras objektet och infogas i meddelandets brödtext.

Om du använder den här överbelastningen för att skicka ett meddelande till en transaktionskö skickas meddelandet till kön med obeställbara meddelanden. Om du vill att meddelandet ska ingå i en transaktion som innehåller andra meddelanden använder du en överlagring som tar en MessageQueueTransaction eller MessageQueueTransactionType som en parameter.

Om du inte anger Formatter egenskapen innan du anropar Send(Object), är formateringsinställningen XmlMessageFormattersom standard .

Egenskapen DefaultPropertiesToSend gäller för alla andra objekt än ett Message. Om du till exempel anger en etikett eller en prioritet med medlemmen DefaultPropertiesToSend gäller dessa värden för alla meddelanden som innehåller ett objekt som inte är av typen Message när programmet skickar det till kön. När du skickar en Messagehar egenskapsvärdena som angetts för Message ha företräde framför DefaultPropertiesToSend och meddelandets Message.Formatter egenskap har företräde framför köns MessageQueue.Formatter egenskap.

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

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

Parametrar

Undantag

Exempel

Följande kodexempel skickar en sträng till en transaktionskö och tar sedan emot ett meddelande från kön.

#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

Kommentarer

Använd den här överlagringen för att skicka ett meddelande som innehåller parametern obj till transaktionskö som MessageQueuerefereras av , med hjälp av en intern transaktionskontext som definieras av parametern transaction . Objektet som du skickar till kön kan vara ett Message eller ett hanterat objekt. Om du skickar något annat objekt än ett Messageserialiseras objektet och infogas i meddelandets brödtext.

Om du använder den här överlagringen för att skicka ett meddelande till en kö som inte är transaktionell kan meddelandet skickas till kön med obeställbara meddelanden utan att ett undantag utlöse.

Om du inte anger Formatter egenskapen innan du anropar Send(Object), är formateringsinställningen XmlMessageFormattersom standard .

Egenskapen DefaultPropertiesToSend gäller för alla andra objekt än ett Message. Om du till exempel anger en etikett eller en prioritet med medlemmen DefaultPropertiesToSend gäller dessa värden för alla meddelanden som innehåller ett objekt som inte är av typen Message när programmet skickar det till kön. När du skickar en Messagehar egenskapsvärdena som angetts för Message ha företräde framför DefaultPropertiesToSend och meddelandets Message.Formatter egenskap har företräde framför köns MessageQueue.Formatter egenskap.

MessageQueueTransaction är trådning lägenhet medveten, så om din lägenhet tillstånd är STA, kan du inte använda transaktionen i flera trådar. Visual Basic anger huvudtrådens tillstånd till STA, så du måste använda MTAThreadAttribute i underrutinen Main. Annars genererar sändning av ett transaktionsmeddelande med hjälp av en annan tråd ett MessageQueueException undantag. Du använder MTAThreadAttribute följande fragment.

<System.MTAThreadAttribute>
 public sub Main()

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

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

Parametrar

Undantag

Exempel

I följande kodexempel visas användningen av 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);

Kommentarer

Använd den här överlagringen för att skicka ett meddelande som innehåller parametern obj till kön som refereras av , med hjälp av MessageQueueen transaktionskontext som definieras av parametern transactionType . Ange Automatic för parametern transactionType om det redan finns en extern transaktionskontext kopplad till tråden som du vill använda för att skicka meddelandet. Ange Single om du vill skicka meddelandet som en enskild intern transaktion. Du kan ange None om du vill skicka ett transaktionsmeddelande till en icke-transaktionstråd.

Objektet som du skickar till kön kan vara ett Message eller ett hanterat objekt. Om du skickar något annat objekt än ett Messageserialiseras objektet och infogas i meddelandets brödtext.

Om du inte anger Formatter egenskapen innan du anropar Send(Object), är formateringsinställningen XmlMessageFormattersom standard .

Egenskapen DefaultPropertiesToSend gäller för alla andra objekt än ett Message. Om du till exempel anger en etikett eller en prioritet med medlemmen DefaultPropertiesToSend gäller dessa värden för alla meddelanden som innehåller ett objekt som inte är av typen Message när programmet skickar det till kön. När du skickar en Messagehar egenskapsvärdena som angetts för Message ha företräde framför DefaultPropertiesToSend och meddelandets Message.Formatter egenskap har företräde framför köns MessageQueue.Formatter egenskap.

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

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

Parametrar

Undantag

Exempel

I följande kodexempel visas användningen av 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");

Kommentarer

Använd den här överlagringen för att skicka ett meddelande som innehåller parametern obj till kön som refereras av MessageQueue. Med den här överlagringen kan du ange strängetiketten som identifierar meddelandet. Objektet du skickar till kön kan vara en Message, en struktur, ett dataobjekt eller ett hanterat objekt. Om du skickar något annat objekt än ett Messageserialiseras objektet och infogas i meddelandets brödtext.

Meddelandeetiketten skiljer sig från meddelandeköetiketten, men båda är programberoende och har ingen ärvd betydelse för Message Queuing.

Om du använder den här överbelastningen för att skicka ett meddelande till en transaktionskö skickas meddelandet till kön med obeställbara meddelanden. Om du vill att meddelandet ska ingå i en transaktion som innehåller andra meddelanden använder du en överlagring som tar en MessageQueueTransaction eller MessageQueueTransactionType som en parameter.

Egenskapen Path för den här MessageQueue instansen måste anges innan du skickar meddelandet. Om du inte anger Formatter egenskapen innan du anropar Send(Object), är formateringsinställningen XmlMessageFormattersom standard .

Egenskapen DefaultPropertiesToSend gäller för alla andra objekt än ett Message. Om du till exempel anger en etikett eller en prioritet med medlemmen DefaultPropertiesToSend gäller dessa värden för alla meddelanden som innehåller ett objekt som inte är av typen Message när programmet skickar det till kön. När du skickar en Messagehar egenskapsvärdena som angetts för Message ha företräde framför DefaultPropertiesToSend och meddelandets Message.Formatter egenskap har företräde framför köns MessageQueue.Formatter egenskap.

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

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

Parametrar

Undantag

Exempel

I följande kodexempel visas användningen av 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();
}

Kommentarer

Använd den här överlagringen för att skicka ett meddelande som innehåller parametern obj till transaktionskö som MessageQueuerefereras av , med hjälp av en intern transaktionskontext som definieras av parametern transaction . Med den här överlagringen kan du ange strängetiketten som identifierar meddelandet. Objektet du skickar till kön kan vara en Message, en struktur, ett dataobjekt eller ett hanterat objekt. Om du skickar något annat objekt än ett Messageserialiseras objektet och infogas i meddelandets brödtext.

Meddelandeetiketten skiljer sig från meddelandeköetiketten, men båda är programberoende och har ingen ärvd betydelse för Message Queuing.

Om du använder den här överlagringen för att skicka ett meddelande till en kö som inte är transaktionell kan meddelandet skickas till kön med obeställbara meddelanden utan att ett undantag utlöse.

Om du inte anger Formatter egenskapen innan du anropar Send(Object), är formateringsinställningen XmlMessageFormattersom standard .

Egenskapen DefaultPropertiesToSend gäller för alla andra objekt än ett Message. Om du till exempel anger en etikett eller en prioritet med medlemmen DefaultPropertiesToSend gäller dessa värden för alla meddelanden som innehåller ett objekt som inte är av typen Message när programmet skickar det till kön. När du skickar en Messagehar egenskapsvärdena som angetts för Message företräde framför DefaultPropertiesToSend och meddelandets Message.Formatter egenskap har företräde framför köns MessageQueue.Formatter egenskap

MessageQueueTransaction är trådning lägenhet medveten, så om din lägenhet tillstånd är STA, kan du inte använda transaktionen i flera trådar. Visual Basic anger huvudtrådens tillstånd till STA, så du måste använda MTAThreadAttribute i underrutinen Main. Annars genererar sändning av ett transaktionsmeddelande med hjälp av en annan tråd ett MessageQueueException undantag. Du använder MTAThreadAttribute följande fragment.

<System.MTAThreadAttribute>
 public sub Main()

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

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

Parametrar

Undantag

Exempel

I följande kodexempel visas användningen av 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);

Kommentarer

Använd den här överlagringen för att skicka ett meddelande som innehåller parametern obj till kön som refereras av , med hjälp av MessageQueueen transaktionskontext som definieras av parametern transactionType . Ange Automatic för parametern transactionType om det redan finns en extern transaktionskontext kopplad till tråden som du vill använda för att skicka meddelandet. Ange Single om du vill skicka meddelandet som en enskild intern transaktion. Du kan ange None om du vill skicka ett transaktionsmeddelande till en icke-transaktionstråd.

Objektet som du skickar till kön kan vara ett Message eller ett hanterat objekt. Om du skickar något annat objekt än ett Messageserialiseras objektet och infogas i meddelandets brödtext. Med den här överlagringen kan du ange strängetiketten som identifierar meddelandet.

Meddelandeetiketten skiljer sig från meddelandeköetiketten, men båda är programberoende och har ingen ärvd betydelse för Message Queuing.

Om du inte anger Formatter egenskapen innan du anropar Send(Object), är formateringsinställningen XmlMessageFormattersom standard .

Egenskapen DefaultPropertiesToSend gäller för alla andra objekt än ett Message. Om du till exempel anger en etikett eller en prioritet med medlemmen DefaultPropertiesToSend gäller dessa värden för alla meddelanden som innehåller ett objekt som inte är av typen Message när programmet skickar det till kön. När du skickar en Messagehar egenskapsvärdena som angetts för Message företräde framför DefaultPropertiesToSend, och meddelandets Message.Formatter egenskap har företräde framför köns MessageQueue.Formatter egenskap.

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

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