MessageQueue.Send Method

Definition

Envia um objeto para uma fila.Sends an object to a queue.

Overloads

Send(Object)

Envia um objeto a uma fila não transacional referenciada por essa MessageQueue.Sends an object to non-transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransaction)

Envia um objeto para a fila transacional referenciada por este MessageQueue.Sends an object to the transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransactionType)

Envia um objeto para a fila referenciada por esse MessageQueue.Sends an object to the queue referenced by this MessageQueue.

Send(Object, String)

Envia um objeto para a fila não transacional referenciada por este MessageQueue e especifica um rótulo para a mensagem.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransaction)

Envia um objeto para a fila transacional referenciada por este MessageQueue e especifica um rótulo para a mensagem.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransactionType)

Envia um objeto para a fila referenciada por esse MessageQueue e especifica um rótulo para a mensagem.Sends an object to the queue referenced by this MessageQueue and specifies a label for the message.

Send(Object)

Envia um objeto a uma fila não transacional referenciada por essa MessageQueue.Sends an object to non-transactional queue referenced by this MessageQueue.

public:
 void Send(System::Object ^ obj);
public void Send (object obj);
member this.Send : obj -> unit
Public Sub Send (obj As Object)

Parameters

obj
Object

O objeto a ser enviado à fila.The object to send to the queue.

Exceptions

A propriedade Path não foi definida.The Path property has not been set.

-ou--or- Erro ao acessar um método do serviço de Enfileiramento de Mensagens.An error occurred when accessing a Message Queuing method.

Examples

O exemplo de código a seguir conecta-se a uma fila de mensagens e envia uma mensagem para a fila.The following code example connects to a message queue and sends a message to the queue.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
   void SendMessage()
   {
      
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      
      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
         
         // Begin the transaction.
         myTransaction->Begin();
         
         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );
         
         // Commit the transaction.
         myTransaction->Commit();
      }
      else
      {
         myQueue->Send( "My Message Data." );
      }

      return;
   }

};

int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Send a message to a queue.
   myNewQueue->SendMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

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

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            return;
        }

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

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }
            else
            {
                myQueue.Send("My Message Data.");
            }

            return;
        }
    }
}
Imports System.Messaging

Public Class MyNewQueue


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

        Public Shared Sub Main()

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

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

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessage()

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

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

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

            Return

        End Sub

End Class

O exemplo de código a seguir envia uma classe de Order definida pelo aplicativo a uma fila e, em seguida, recebe uma mensagem dessa fila.The following code example sends an application-defined Order class to a queue and then receives a message from that queue.

Remarks

Use essa sobrecarga para enviar uma mensagem que contém o parâmetro obj para a fila referenciada pelo MessageQueue.Use this overload to send a message that contains the obj parameter to the queue referenced by the MessageQueue. O objeto que você envia para a fila pode ser um Message ou qualquer objeto gerenciado.The object you send to the queue can be a Message or any managed object. Se você enviar qualquer objeto que não seja um Message, o objeto será serializado e inserido no corpo da mensagem.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

Se você usar essa sobrecarga para enviar uma mensagem a uma fila transacional, a mensagem será enviada para a fila de mensagens mortas.If you use this overload to send a message to a transactional queue, the message will be sent to the dead-letter queue. Se você quiser que a mensagem faça parte de uma transação que contém outras mensagens, use uma sobrecarga que usa um MessageQueueTransaction ou MessageQueueTransactionType como um parâmetro.If you want the message to be part of a transaction that contains other messages, use an overload that takes a MessageQueueTransaction or MessageQueueTransactionType as a parameter.

Se você não definir a propriedade Formatter antes de chamar Send(Object), o formatador usa como padrão a XmlMessageFormatter.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

A propriedade DefaultPropertiesToSend se aplica a qualquer objeto que não seja um Message.The DefaultPropertiesToSend property applies to any object other than a Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o membro DefaultPropertiesToSend, esses valores se aplicarão a qualquer mensagem que contenha um objeto que não seja do tipo Message quando o aplicativo o enviar para a fila.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Ao enviar um Message, os valores de propriedade definidos para o Message têm precedência sobre DefaultPropertiesToSend e a propriedade Message.Formatter da mensagem tem precedência sobre a propriedade MessageQueue.Formatter da fila.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

A tabela a seguir mostra se esse método está disponível em vários modos de grupo de trabalho.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabalhoWorkgroup mode DisponívelAvailable
Computador localLocal computer SimYes
Computador local e nome de formato diretoLocal computer and direct format name SimYes
Computador remotoRemote computer NãoNo
Computador remoto e nome de formato diretoRemote computer and direct format name SimYes

See also

Send(Object, MessageQueueTransaction)

Envia um objeto para a fila transacional referenciada por este MessageQueue.Sends an object to the transactional queue referenced by this MessageQueue.

public:
 void Send(System::Object ^ obj, System::Messaging::MessageQueueTransaction ^ transaction);
public void Send (object obj, System.Messaging.MessageQueueTransaction transaction);
member this.Send : obj * System.Messaging.MessageQueueTransaction -> unit
Public Sub Send (obj As Object, transaction As MessageQueueTransaction)

Parameters

obj
Object

O objeto a ser enviado à fila.The object to send to the queue.

Exceptions

O parâmetro transaction é null.The transaction parameter is null.

A propriedade Path não foi definida.The Path property has not been set.

-ou--or- O aplicativo do serviço de enfileiramento de mensagens indicou um uso incorreto de transações.The Message Queuing application indicated an incorrect transaction use.

-ou--or- Erro ao acessar um método do serviço de Enfileiramento de Mensagens.An error occurred when accessing a Message Queuing method.

Examples

O exemplo de código a seguir envia uma cadeia de caracteres para uma fila transacional e recebe uma mensagem dessa fila.The following code example sends a string to a transactional queue and then receives a message from that queue.

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

using namespace System;
using namespace System::Messaging;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends a message to a queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }


   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessageTransactional()
   {
      // Connect to a transactional queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         Message^ myMessage = myQueue->Receive( myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }

         // Else catch other sources of MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
// 
// This example sends and receives a message from
// a transactional queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessageTransactional();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   return 0;
}
using System;
using System.Messaging;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //
        // This example sends and receives a message from
        // a transactional queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessageTransactional();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();
        
            return;
        }

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

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessageTransactional()
        {
            // Connect to a transactional queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                Message myMessage =	myQueue.Receive(myTransaction);
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }
                
                // Else catch other sources of MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}
Imports System.Messaging

   
Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        ' 
        ' This example sends and receives a message from
        ' a transactional queue.
        '

        Public Shared Sub Main()

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

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

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional()

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessageTransactional()

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

            ' Send a message to the queue.
            If myQueue.Transactional = True Then
                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()
            End If

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessageTransactional()

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

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                Dim myMessage As Message = _
                    myQueue.Receive(myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                End If

                ' Else catch other sources of a MessageQueueException.


                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as 
                ' InvalidOperationException, thrown when the formatter
                ' cannot deserialize the message.

            End Try

            Return

        End Sub

End Class

Remarks

Use essa sobrecarga para enviar uma mensagem que contém o parâmetro obj para a fila transacional referenciada pelo MessageQueue, usando um contexto de transação interno definido pelo parâmetro transaction.Use this overload to send a message that contains the obj parameter to the transactional queue referenced by the MessageQueue, using an internal transaction context defined by the transaction parameter. O objeto que você envia para a fila pode ser um Message ou qualquer objeto gerenciado.The object you send to the queue can be a Message or any managed object. Se você enviar qualquer objeto que não seja um Message, o objeto será serializado e inserido no corpo da mensagem.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

Se você usar essa sobrecarga para enviar uma mensagem a uma fila não transacional, a mensagem poderá ser enviada para a fila de mensagens mortas sem gerar uma exceção.If you use this overload to send a message to a non-transactional queue, the message might be sent to the dead-letter queue without throwing an exception.

Se você não definir a propriedade Formatter antes de chamar Send(Object), o formatador usa como padrão a XmlMessageFormatter.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

A propriedade DefaultPropertiesToSend se aplica a qualquer objeto que não seja um Message.The DefaultPropertiesToSend property applies to any object other than a Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o membro DefaultPropertiesToSend, esses valores se aplicarão a qualquer mensagem que contenha um objeto que não seja do tipo Message quando o aplicativo o enviar para a fila.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Ao enviar um Message, os valores de propriedade definidos para o Message têm precedência sobre DefaultPropertiesToSend e a propriedade Message.Formatter da mensagem tem precedência sobre a propriedade MessageQueue.Formatter da fila.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

o MessageQueueTransaction está segmentando o Apartment com reconhecimento, portanto, se o estado de seu apartamento for STA, você não poderá usar a transação em vários threads.MessageQueueTransaction is threading apartment aware, so if your apartment state is STA, you cannot use the transaction in multiple threads. Visual Basic define o estado do thread principal como STA, portanto, você deve aplicar o MTAThreadAttribute na sub-rotina Main.Visual Basic sets the state of the main thread to STA, so you must apply the MTAThreadAttribute in the Main subroutine. Caso contrário, o envio de uma mensagem transacional usando outro thread gerará uma exceção MessageQueueException.Otherwise, sending a transactional message using another thread throws a MessageQueueException exception. Você aplica o MTAThreadAttribute usando o fragmento a seguir.You apply the MTAThreadAttribute by using the following fragment.

<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.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabalhoWorkgroup mode DisponívelAvailable
Computador localLocal computer SimYes
Computador local e nome de formato diretoLocal computer and direct format name SimYes
Computador remotoRemote computer NãoNo
Computador remoto e nome de formato diretoRemote computer and direct format name SimYes

See also

Send(Object, MessageQueueTransactionType)

Envia um objeto para a fila referenciada por esse MessageQueue.Sends an object to the queue referenced by this MessageQueue.

public:
 void Send(System::Object ^ obj, System::Messaging::MessageQueueTransactionType transactionType);
public void Send (object obj, System.Messaging.MessageQueueTransactionType transactionType);
member this.Send : obj * System.Messaging.MessageQueueTransactionType -> unit
Public Sub Send (obj As Object, transactionType As MessageQueueTransactionType)

Parameters

obj
Object

O objeto a ser enviado à fila.The object to send to the queue.

transactionType
MessageQueueTransactionType

Um dos valores de MessageQueueTransactionType, que descreve o tipo de contexto de transação associado à mensagem.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Exceptions

O parâmetro transactionType não é um dos membros do MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

A propriedade Path não foi definida.The Path property has not been set.

-ou--or- Erro ao acessar um método do serviço de Enfileiramento de Mensagens.An error occurred when accessing a Message Queuing method.

Examples

O exemplo de código a seguir demonstra o uso de Send(Object, MessageQueueTransactionType).The following code example demonstrates the use of 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);

Remarks

Use essa sobrecarga para enviar uma mensagem que contém o parâmetro obj para a fila referenciada pelo MessageQueue, usando um contexto de transação definido pelo parâmetro transactionType.Use this overload to send a message that contains the obj parameter to the queue referenced by the MessageQueue, using a transaction context defined by the transactionType parameter. Especifique Automatic para o parâmetro transactionType se já houver um contexto de transação externa anexado ao thread que você deseja usar para enviar a mensagem.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to send the message. Especifique Single se você deseja enviar a mensagem como uma única transação interna.Specify Single if you want to send the message as a single internal transaction. Você pode especificar None se quiser enviar uma mensagem transacional para um thread não transacional.You can specify None if you want to send a transactional message to a non-transactional thread.

O objeto que você envia para a fila pode ser um Message ou qualquer objeto gerenciado.The object you send to the queue can be a Message or any managed object. Se você enviar qualquer objeto que não seja um Message, o objeto será serializado e inserido no corpo da mensagem.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

Se você não definir a propriedade Formatter antes de chamar Send(Object), o formatador usa como padrão a XmlMessageFormatter.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

A propriedade DefaultPropertiesToSend se aplica a qualquer objeto que não seja um Message.The DefaultPropertiesToSend property applies to any object other than a Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o membro DefaultPropertiesToSend, esses valores se aplicarão a qualquer mensagem que contenha um objeto que não seja do tipo Message quando o aplicativo o enviar para a fila.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Ao enviar um Message, os valores de propriedade definidos para o Message têm precedência sobre DefaultPropertiesToSend e a propriedade Message.Formatter da mensagem tem precedência sobre a propriedade MessageQueue.Formatter da fila.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

A tabela a seguir mostra se esse método está disponível em vários modos de grupo de trabalho.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabalhoWorkgroup mode DisponívelAvailable
Computador localLocal computer SimYes
Computador local e nome de formato diretoLocal computer and direct format name SimYes
Computador remotoRemote computer NãoNo
Computador remoto e nome de formato diretoRemote computer and direct format name SimYes

See also

Send(Object, String)

Envia um objeto para a fila não transacional referenciada por este MessageQueue e especifica um rótulo para a mensagem.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the message.

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

obj
Object

O objeto a ser enviado à fila.The object to send to the queue.

label
String

O rótulo da mensagem.The label of the message.

Exceptions

O parâmetro label é null.The label parameter is null.

A propriedade Path não foi definida.The Path property has not been set.

-ou--or- Erro ao acessar um método do serviço de Enfileiramento de Mensagens.An error occurred when accessing a Message Queuing method.

Examples

O exemplo de código a seguir demonstra o uso de Send(Object, String).The following code example demonstrates the use of 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");

Remarks

Use essa sobrecarga para enviar uma mensagem que contém o parâmetro obj para a fila referenciada pelo MessageQueue.Use this overload to send a message that contains the obj parameter to the queue referenced by the MessageQueue. Com essa sobrecarga, você pode especificar o rótulo da cadeia de caracteres que identifica a mensagem.With this overload, you can specify the string label that identifies the message. O objeto enviado para a fila pode ser um Message, uma estrutura, um objeto de dados ou qualquer objeto gerenciado.The object you send to the queue can be a Message, a structure, a data object, or any managed object. Se você enviar qualquer objeto que não seja um Message, o objeto será serializado e inserido no corpo da mensagem.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

O rótulo da mensagem é diferente do rótulo da fila de mensagens, mas ambos são dependentes do aplicativo e não têm significado de herança para o enfileiramento de mensagens.The message label is distinct from the message queue label, but both are application-dependent and have no inherit meaning to Message Queuing.

Se você usar essa sobrecarga para enviar uma mensagem a uma fila transacional, a mensagem será enviada para a fila de mensagens mortas.If you use this overload to send a message to a transactional queue, the message will be sent to the dead-letter queue. Se você quiser que a mensagem faça parte de uma transação que contém outras mensagens, use uma sobrecarga que usa um MessageQueueTransaction ou MessageQueueTransactionType como um parâmetro.If you want the message to be part of a transaction that contains other messages, use an overload that takes a MessageQueueTransaction or MessageQueueTransactionType as a parameter.

A propriedade Path para essa instância de MessageQueue deve ser especificada antes de você enviar a mensagem.The Path property for this MessageQueue instance must be specified before you send the message. Se você não definir a propriedade Formatter antes de chamar Send(Object), o formatador usa como padrão a XmlMessageFormatter.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

A propriedade DefaultPropertiesToSend se aplica a qualquer objeto que não seja um Message.The DefaultPropertiesToSend property applies to any object other than a Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o membro DefaultPropertiesToSend, esses valores se aplicarão a qualquer mensagem que contenha um objeto que não seja do tipo Message quando o aplicativo o enviar para a fila.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Ao enviar um Message, os valores de propriedade definidos para o Message têm precedência sobre DefaultPropertiesToSend e a propriedade Message.Formatter da mensagem tem precedência sobre a propriedade MessageQueue.Formatter da fila.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

A tabela a seguir mostra se esse método está disponível em vários modos de grupo de trabalho.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabalhoWorkgroup mode DisponívelAvailable
Computador localLocal computer SimYes
Computador local e nome de formato diretoLocal computer and direct format name SimYes
Computador remotoRemote computer NãoNo
Computador remoto e nome de formato diretoRemote computer and direct format name SimYes

See also

Send(Object, String, MessageQueueTransaction)

Envia um objeto para a fila transacional referenciada por este MessageQueue e especifica um rótulo para a mensagem.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the message.

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

obj
Object

O objeto a ser enviado à fila.The object to send to the queue.

label
String

O rótulo da mensagem.The label of the message.

Exceptions

O parâmetro label é null.The label parameter is null.

-ou--or- O parâmetro transaction é null.The transaction parameter is null.

A propriedade Path não foi definida.The Path property has not been set.

-ou--or- O aplicativo do serviço de enfileiramento de mensagens indicou um uso incorreto de transação.The Message Queuing application indicated an incorrect transaction usage.

-ou--or- Erro ao acessar um método do serviço de Enfileiramento de Mensagens.An error occurred when accessing a Message Queuing method.

Examples

O exemplo de código a seguir demonstra o uso de Send(Object, String, MessageQueueTransaction).The following code example demonstrates the use of 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();
}

Remarks

Use essa sobrecarga para enviar uma mensagem que contém o parâmetro obj para a fila transacional referenciada pelo MessageQueue, usando um contexto de transação interno definido pelo parâmetro transaction.Use this overload to send a message that contains the obj parameter to the transactional queue referenced by the MessageQueue, using an internal transaction context defined by the transaction parameter. Com essa sobrecarga, você pode especificar o rótulo da cadeia de caracteres que identifica a mensagem.With this overload, you can specify the string label that identifies the message. O objeto enviado para a fila pode ser um Message, uma estrutura, um objeto de dados ou qualquer objeto gerenciado.The object you send to the queue can be a Message, a structure, a data object, or any managed object. Se você enviar qualquer objeto que não seja um Message, o objeto será serializado e inserido no corpo da mensagem.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

O rótulo da mensagem é diferente do rótulo da fila de mensagens, mas ambos são dependentes do aplicativo e não têm significado de herança para o enfileiramento de mensagens.The message label is distinct from the message queue label, but both are application-dependent and have no inherit meaning to Message Queuing.

Se você usar essa sobrecarga para enviar uma mensagem a uma fila não transacional, a mensagem poderá ser enviada para a fila de mensagens mortas sem gerar uma exceção.If you use this overload to send a message to a non-transactional queue, the message might be sent to the dead-letter queue without throwing an exception.

Se você não definir a propriedade Formatter antes de chamar Send(Object), o formatador usa como padrão a XmlMessageFormatter.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

A propriedade DefaultPropertiesToSend se aplica a qualquer objeto que não seja um Message.The DefaultPropertiesToSend property applies to any object other than a Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o membro DefaultPropertiesToSend, esses valores se aplicarão a qualquer mensagem que contenha um objeto que não seja do tipo Message quando o aplicativo o enviar para a fila.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Ao enviar um Message, os valores de propriedade definidos para o Message têm precedência sobre DefaultPropertiesToSend e a propriedade Message.Formatter da mensagem tem precedência sobre a propriedade MessageQueue.Formatter da filaWhen sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property

o MessageQueueTransaction está segmentando o Apartment com reconhecimento, portanto, se o estado de seu apartamento for STA, você não poderá usar a transação em vários threads.MessageQueueTransaction is threading apartment aware, so if your apartment state is STA, you cannot use the transaction in multiple threads. Visual Basic define o estado do thread principal como STA, portanto, você deve aplicar o MTAThreadAttribute na sub-rotina Main.Visual Basic sets the state of the main thread to STA, so you must apply the MTAThreadAttribute in the Main subroutine. Caso contrário, o envio de uma mensagem transacional usando outro thread gerará uma exceção MessageQueueException.Otherwise, sending a transactional message using another thread throws a MessageQueueException exception. Você aplica o MTAThreadAttribute usando o fragmento a seguir.You apply the MTAThreadAttribute by using the following fragment.

<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.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabalhoWorkgroup mode DisponívelAvailable
Computador localLocal computer SimYes
Computador local e nome de formato diretoLocal computer and direct format name SimYes
Computador remotoRemote computer NãoNo
Computador remoto e nome de formato diretoRemote computer and direct format name SimYes

See also

Send(Object, String, MessageQueueTransactionType)

Envia um objeto para a fila referenciada por esse MessageQueue e especifica um rótulo para a mensagem.Sends an object to the queue referenced by this MessageQueue and specifies a label for the message.

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

obj
Object

O objeto a ser enviado à fila.The object to send to the queue.

label
String

O rótulo da mensagem.The label of the message.

transactionType
MessageQueueTransactionType

Um dos valores de MessageQueueTransactionType, que descreve o tipo de contexto de transação associado à mensagem.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Exceptions

O parâmetro label é null.The label parameter is null.

O aplicativo do serviço de enfileiramento de mensagens indicou um uso incorreto de transação.The Message Queuing application indicated an incorrect transaction usage.

O parâmetro transactionType não é um dos membros do MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

A propriedade Path não foi definida.The Path property has not been set.

-ou--or- Erro ao acessar um método do serviço de Enfileiramento de Mensagens.An error occurred when accessing a Message Queuing method.

Examples

O exemplo de código a seguir demonstra o uso de Send(Object, String, MessageQueueTransactionType).The following code example demonstrates the use of 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);

Remarks

Use essa sobrecarga para enviar uma mensagem que contém o parâmetro obj para a fila referenciada pelo MessageQueue, usando um contexto de transação definido pelo parâmetro transactionType.Use this overload to send a message that contains the obj parameter to the queue referenced by the MessageQueue, using a transaction context defined by the transactionType parameter. Especifique Automatic para o parâmetro transactionType se já houver um contexto de transação externa anexado ao thread que você deseja usar para enviar a mensagem.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to send the message. Especifique Single se você deseja enviar a mensagem como uma única transação interna.Specify Single if you want to send the message as a single internal transaction. Você pode especificar None se quiser enviar uma mensagem transacional para um thread não transacional.You can specify None if you want to send a transactional message to a non-transactional thread.

O objeto que você envia para a fila pode ser um Message ou qualquer objeto gerenciado.The object you send to the queue can be a Message or any managed object. Se você enviar qualquer objeto que não seja um Message, o objeto será serializado e inserido no corpo da mensagem.If you send any object other than a Message, the object is serialized and inserted into the body of the message. Com essa sobrecarga, você pode especificar o rótulo da cadeia de caracteres que identifica a mensagem.With this overload, you can specify the string label that identifies the message.

O rótulo da mensagem é diferente do rótulo da fila de mensagens, mas ambos são dependentes do aplicativo e não têm significado de herança para o enfileiramento de mensagens.The message label is distinct from the message queue label, but both are application-dependent and have no inherit meaning to Message Queuing.

Se você não definir a propriedade Formatter antes de chamar Send(Object), o formatador usa como padrão a XmlMessageFormatter.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

A propriedade DefaultPropertiesToSend se aplica a qualquer objeto que não seja um Message.The DefaultPropertiesToSend property applies to any object other than a Message. Se você especificar, por exemplo, um rótulo ou uma prioridade usando o membro DefaultPropertiesToSend, esses valores se aplicarão a qualquer mensagem que contenha um objeto que não seja do tipo Message quando o aplicativo o enviar para a fila.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Ao enviar um Message, os valores de propriedade definidos para o Message têm precedência sobre DefaultPropertiesToSend, e a propriedade Message.Formatter da mensagem tem precedência sobre a propriedade MessageQueue.Formatter da fila.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend, and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

A tabela a seguir mostra se esse método está disponível em vários modos de grupo de trabalho.The following table shows whether this method is available in various Workgroup modes.

Modo de grupo de trabalhoWorkgroup mode DisponívelAvailable
Computador localLocal computer SimYes
Computador local e nome de formato diretoLocal computer and direct format name SimYes
Computador remotoRemote computer NãoNo
Computador remoto e nome de formato diretoRemote computer and direct format name SimYes

See also

Applies to