MessageQueue.Send Método

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

public void Send(object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

Parâmetros

Exceções

Exemplos

O exemplo de código a seguir se conecta a uma fila de mensagens e envia uma mensagem para a fila.

#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

O exemplo de código a seguir envia uma classe definida pelo Order aplicativo para uma fila e, em seguida, recebe uma mensagem dessa fila.

Comentários

Use essa sobrecarga para enviar uma mensagem que contenha o obj parâmetro para a fila referenciada pelo MessageQueue. O objeto que você envia para a fila pode ser um Message ou qualquer objeto gerenciado. Se você enviar qualquer objeto diferente de um Message, o objeto será serializado e inserido no corpo da mensagem.

Se você usar essa sobrecarga para enviar uma mensagem para uma fila transacional, a mensagem será enviada para a fila de mensagens mortas. Se você quiser que a mensagem faça parte de uma transação que contenha outras mensagens, use uma sobrecarga que usa um MessageQueueTransaction ou MessageQueueTransactionType como parâmetro.

Se você não definir a Formatter propriedade antes de chamar Send(Object), o formatador usará o XmlMessageFormatterpadrão .

A DefaultPropertiesToSend propriedade se aplica a qualquer objeto que não seja um Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o DefaultPropertiesToSend membro, esses valores se aplicam a qualquer mensagem que contenha um objeto que não seja do tipo Message quando seu aplicativo o envia para a fila. Ao enviar um Message, os valores de propriedade definidos para a Message precedência DefaultPropertiesToSend de tomada e a propriedade da Message.Formatter mensagem tem precedência sobre a propriedade da MessageQueue.Formatter fila.

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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

Parâmetros

Exceções

Exemplos

O exemplo de código a seguir envia uma cadeia de caracteres para uma fila transacional e, em seguida, recebe uma mensagem dessa fila.

#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

Comentários

Use essa sobrecarga para enviar uma mensagem que contenha o obj parâmetro para a fila transacional referenciada pelo MessageQueue, usando um contexto de transação interno definido pelo transaction parâmetro. O objeto que você envia para a fila pode ser um Message ou qualquer objeto gerenciado. Se você enviar qualquer objeto diferente de um Message, o objeto será serializado e inserido no corpo da mensagem.

Se você usar essa sobrecarga para enviar uma mensagem para uma fila não transacional, a mensagem poderá ser enviada para a fila de mensagens mortas sem gerar uma exceção.

Se você não definir a Formatter propriedade antes de chamar Send(Object), o formatador usará o XmlMessageFormatterpadrão .

A DefaultPropertiesToSend propriedade se aplica a qualquer objeto que não seja um Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o DefaultPropertiesToSend membro, esses valores se aplicam a qualquer mensagem que contenha um objeto que não seja do tipo Message quando seu aplicativo o envia para a fila. Ao enviar um Message, os valores de propriedade definidos para a Message precedência DefaultPropertiesToSend de tomada e a propriedade da Message.Formatter mensagem tem precedência sobre a propriedade da MessageQueue.Formatter fila.

MessageQueueTransaction é threading apartment aware, portanto, se o estado do seu apartamento é STA, você não pode usar a transação em vários threads. O Visual Basic define o estado do thread principal como STA, portanto, você deve aplicar a MTAThreadAttributeMain sub-rotina. Caso contrário, enviar uma mensagem transacional usando outro thread gera uma MessageQueueException exceção. Aplique-o MTAThreadAttribute usando o fragmento a seguir.

<System.MTAThreadAttribute>
 public sub Main()

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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

Parâmetros

Exceções

Exemplos

O exemplo de código a seguir demonstra o uso de 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);

Comentários

Use essa sobrecarga para enviar uma mensagem que contém o obj parâmetro para a fila referenciada pelo MessageQueue, usando um contexto de transação definido pelo transactionType parâmetro. Especifique Automatic o transactionType parâmetro se já houver um contexto de transação externo anexado ao thread que você deseja usar para enviar a mensagem. Especifique Single se deseja enviar a mensagem como uma única transação interna. Você pode especificar None se deseja enviar uma mensagem transacional para um thread não transacional.

O objeto que você envia para a fila pode ser um Message ou qualquer objeto gerenciado. Se você enviar qualquer objeto diferente de um Message, o objeto será serializado e inserido no corpo da mensagem.

Se você não definir a Formatter propriedade antes de chamar Send(Object), o formatador usará o XmlMessageFormatterpadrão .

A DefaultPropertiesToSend propriedade se aplica a qualquer objeto que não seja um Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o DefaultPropertiesToSend membro, esses valores se aplicam a qualquer mensagem que contenha um objeto que não seja do tipo Message quando seu aplicativo o envia para a fila. Ao enviar um Message, os valores de propriedade definidos para a Message precedência DefaultPropertiesToSend de tomada e a propriedade da Message.Formatter mensagem tem precedência sobre a propriedade da MessageQueue.Formatter fila.

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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

Parâmetros

Exceções

Exemplos

O exemplo de código a seguir demonstra o uso de 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");

Comentários

Use essa sobrecarga para enviar uma mensagem que contenha o obj parâmetro para a fila referenciada pelo MessageQueue. Com essa sobrecarga, você pode especificar o rótulo de cadeia de caracteres que identifica a mensagem. O objeto que você envia para a fila pode ser uma Messageestrutura, um objeto de dados ou qualquer objeto gerenciado. Se você enviar qualquer objeto diferente de um Message, o objeto será serializado e inserido no corpo da mensagem.

O rótulo da mensagem é distinto do rótulo da fila de mensagens, mas ambos são dependentes do aplicativo e não têm nenhum significado herdado para o Enfileiramento de Mensagens.

Se você usar essa sobrecarga para enviar uma mensagem para uma fila transacional, a mensagem será enviada para a fila de mensagens mortas. Se você quiser que a mensagem faça parte de uma transação que contenha outras mensagens, use uma sobrecarga que usa um MessageQueueTransaction ou MessageQueueTransactionType como parâmetro.

A Path propriedade dessa MessageQueue instância deve ser especificada antes de você enviar a mensagem. Se você não definir a Formatter propriedade antes de chamar Send(Object), o formatador usará o XmlMessageFormatterpadrão .

A DefaultPropertiesToSend propriedade se aplica a qualquer objeto que não seja um Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o DefaultPropertiesToSend membro, esses valores se aplicam a qualquer mensagem que contenha um objeto que não seja do tipo Message quando seu aplicativo o envia para a fila. Ao enviar um Message, os valores de propriedade definidos para a Message precedência DefaultPropertiesToSend de tomada e a propriedade da Message.Formatter mensagem tem precedência sobre a propriedade da MessageQueue.Formatter fila.

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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

Parâmetros

Exceções

Exemplos

O exemplo de código a seguir demonstra o uso de 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();
}

Comentários

Use essa sobrecarga para enviar uma mensagem que contenha o obj parâmetro para a fila transacional referenciada pelo MessageQueue, usando um contexto de transação interno definido pelo transaction parâmetro. Com essa sobrecarga, você pode especificar o rótulo de cadeia de caracteres que identifica a mensagem. O objeto que você envia para a fila pode ser uma Messageestrutura, um objeto de dados ou qualquer objeto gerenciado. Se você enviar qualquer objeto diferente de um Message, o objeto será serializado e inserido no corpo da mensagem.

O rótulo da mensagem é distinto do rótulo da fila de mensagens, mas ambos são dependentes do aplicativo e não têm nenhum significado herdado para o Enfileiramento de Mensagens.

Se você usar essa sobrecarga para enviar uma mensagem para uma fila não transacional, a mensagem poderá ser enviada para a fila de mensagens mortas sem gerar uma exceção.

Se você não definir a Formatter propriedade antes de chamar Send(Object), o formatador usará o XmlMessageFormatterpadrão .

A DefaultPropertiesToSend propriedade se aplica a qualquer objeto que não seja um Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o DefaultPropertiesToSend membro, esses valores se aplicam a qualquer mensagem que contenha um objeto que não seja do tipo Message quando seu aplicativo o envia para a fila. Ao enviar um Message, os valores de propriedade definidos para a Message precedência DefaultPropertiesToSend de tomada e a propriedade da Message.Formatter mensagem tem precedência sobre a propriedade da MessageQueue.Formatter fila

MessageQueueTransaction é threading apartment aware, portanto, se o estado do seu apartamento é STA, você não pode usar a transação em vários threads. O Visual Basic define o estado do thread principal como STA, portanto, você deve aplicar a MTAThreadAttributeMain sub-rotina. Caso contrário, enviar uma mensagem transacional usando outro thread gera uma MessageQueueException exceção. Aplique-o MTAThreadAttribute usando o fragmento a seguir.

<System.MTAThreadAttribute>
 public sub Main()

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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

Parâmetros

Exceções

Exemplos

O exemplo de código a seguir demonstra o uso de 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);

Comentários

Use essa sobrecarga para enviar uma mensagem que contém o obj parâmetro para a fila referenciada pelo MessageQueue, usando um contexto de transação definido pelo transactionType parâmetro. Especifique Automatic o transactionType parâmetro se já houver um contexto de transação externo anexado ao thread que você deseja usar para enviar a mensagem. Especifique Single se deseja enviar a mensagem como uma única transação interna. Você pode especificar None se deseja enviar uma mensagem transacional para um thread não transacional.

O objeto que você envia para a fila pode ser um Message ou qualquer objeto gerenciado. Se você enviar qualquer objeto diferente de um Message, o objeto será serializado e inserido no corpo da mensagem. Com essa sobrecarga, você pode especificar o rótulo de cadeia de caracteres que identifica a mensagem.

O rótulo da mensagem é distinto do rótulo da fila de mensagens, mas ambos são dependentes do aplicativo e não têm nenhum significado herdado para o Enfileiramento de Mensagens.

Se você não definir a Formatter propriedade antes de chamar Send(Object), o formatador usará o XmlMessageFormatterpadrão .

A DefaultPropertiesToSend propriedade se aplica a qualquer objeto que não seja um Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o DefaultPropertiesToSend membro, esses valores se aplicam a qualquer mensagem que contenha um objeto que não seja do tipo Message quando seu aplicativo o envia para a fila. Ao enviar um Message, os valores de propriedade definidos para a Message precedência de tomada sobre DefaultPropertiesToSend, e a propriedade da Message.Formatter mensagem tem precedência sobre a propriedade da MessageQueue.Formatter fila.

A tabela a seguir mostra se esse método está disponível em vários modos de Grupo de Trabalho.

Confira também

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