MessageQueue.Send Método

Referencia

Definición

Espacio de nombres:: System.Messaging

Ensamblado:: System.Messaging.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Envía un objeto a una cola.

Sobrecargas

Send(Object)	Envía un objeto a la cola no transaccional a la que hace referencia este objeto MessageQueue.
Send(Object, MessageQueueTransaction)	Envía un objeto a la cola transaccional a la que hace referencia este objeto MessageQueue.
Send(Object, MessageQueueTransactionType)	Envía un objeto a la cola a la que hace referencia esta MessageQueue.
Send(Object, String)	Envía un objeto a la cola no transaccional a la que hace referencia este objeto MessageQueue y especifica una etiqueta para el mensaje.
Send(Object, String, MessageQueueTransaction)	Envía un objeto a la cola transaccional a la que hace referencia este objeto MessageQueue y especifica una etiqueta para el mensaje.
Send(Object, String, MessageQueueTransactionType)	Envía un objeto a la cola a la que hace referencia esta MessageQueue y especifica una etiqueta para el mensaje.

Send(Object)

Envía un objeto a la cola no transaccional a la que hace referencia este objeto MessageQueue.

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

public void Send (object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

Parámetros

obj: Object

Objeto que se va a enviar a la cola.

Excepciones

MessageQueueException

No se ha establecido el valor de la propiedad Path.

o bien

Error al obtener acceso a un método de Message Queuing.

Ejemplos

El ejemplo de código siguiente se conecta a una cola de mensajes y envía un mensaje a la cola.

#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

En el ejemplo de código siguiente se envía una clase definida por Order la aplicación a una cola y, a continuación, se recibe un mensaje de esa cola.

Comentarios

Use esta sobrecarga para enviar un mensaje que contenga el obj parámetro a la cola a la que hace referencia .MessageQueue El objeto que envía a la cola puede ser o Message cualquier objeto administrado. Si envía algún objeto distinto de , Messageel objeto se serializa e inserta en el cuerpo del mensaje.

Si usa esta sobrecarga para enviar un mensaje a una cola transaccional, el mensaje se enviará a la cola de mensajes fallidos. Si desea que el mensaje forme parte de una transacción que contenga otros mensajes, use una sobrecarga que tome o MessageQueueTransaction MessageQueueTransactionType como parámetro.

Si no establece la Formatter propiedad antes de llamar a Send(Object), el formateador tiene como valor predeterminado XmlMessageFormatter.

La DefaultPropertiesToSend propiedad se aplica a cualquier objeto que no sea .Message Si especifica, por ejemplo, una etiqueta o una prioridad mediante el DefaultPropertiesToSend miembro , estos valores se aplican a cualquier mensaje que contenga un objeto que no sea de tipo Message cuando la aplicación la envíe a la cola. Al enviar un Message, los valores de propiedad establecidos para tienen Message prioridad sobre DefaultPropertiesToSend y la propiedad del Message.Formatter mensaje tiene prioridad sobre la propiedad de MessageQueue.Formatter la cola.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo	Disponible
Equipo local	Sí
Equipo local y nombre de formato directo	Sí
Equipo remoto	No
Equipo remoto y nombre de formato directo	Sí

Consulte también

Se aplica a

Send(Object, MessageQueueTransaction)

Envía un objeto a la cola transaccional a la que hace referencia este objeto 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)

Parámetros

obj: Object

Objeto que se va a enviar a la cola.

transaction: MessageQueueTransaction

Objeto MessageQueueTransaction.

Excepciones

ArgumentNullException

El parámetro transaction es null.

MessageQueueException

No se ha establecido el valor de la propiedad Path.

o bien

La aplicación de Message Queuing indicó un uso incorrecto de la transacción.

o bien

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En el ejemplo de código siguiente se envía una cadena a una cola transaccional y, a continuación, se recibe un mensaje de esa cola.

#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

Comentarios

Use esta sobrecarga para enviar un mensaje que contenga el obj parámetro a la cola transaccional a la que hace referencia el MessageQueue, mediante un contexto de transacción interno definido por el transaction parámetro . El objeto que envía a la cola puede ser o Message cualquier objeto administrado. Si envía algún objeto distinto de , Messageel objeto se serializa e inserta en el cuerpo del mensaje.

Si usa esta sobrecarga para enviar un mensaje a una cola no transaccional, es posible que el mensaje se envíe a la cola de mensajes fallidos sin producir una excepción.

Si no establece la Formatter propiedad antes de llamar a Send(Object), el formateador tiene como valor predeterminado XmlMessageFormatter.

MessageQueueTransaction es consciente del contenedor de subprocesos, por lo que si el estado del apartamento es STA, no puede usar la transacción en varios subprocesos. Visual Basic establece el estado del subproceso STAprincipal en , por lo que debe aplicar en MTAThreadAttribute la Main subrutina. De lo contrario, al enviar un mensaje transaccional mediante otro subproceso se producirá una excepción MessageQueueException. Se aplica MTAThreadAttribute mediante el fragmento siguiente.

<System.MTAThreadAttribute>
 public sub Main()

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo	Disponible
Equipo local	Sí
Equipo local y nombre de formato directo	Sí
Equipo remoto	No
Equipo remoto y nombre de formato directo	Sí

Consulte también

Se aplica a

Send(Object, MessageQueueTransactionType)

Envía un objeto a la cola a la que hace referencia esta 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)

Parámetros

obj: Object

Objeto que se va a enviar a la cola.

transactionType: MessageQueueTransactionType

Uno de los valores de MessageQueueTransactionType, que describe el tipo de contexto de transacción que se va a asociar al mensaje.

Excepciones

InvalidEnumArgumentException

El parámetro transactionType no es un miembro de MessageQueueTransactionType.

MessageQueueException

No se ha establecido el valor de la propiedad Path.

o bien

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En el siguiente ejemplo de código se muestra el 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);

Comentarios

Use esta sobrecarga para enviar un mensaje que contenga el obj parámetro a la cola a la que hace referencia el MessageQueue, mediante un contexto de transacción definido por el transactionType parámetro . Especifique Automatic para el transactionType parámetro si ya hay un contexto de transacción externo asociado al subproceso que desea usar para enviar el mensaje. Especifique Single si desea enviar el mensaje como una única transacción interna. Puede especificar None si desea enviar un mensaje transaccional a un subproceso no transaccional.

El objeto que envía a la cola puede ser o Message cualquier objeto administrado. Si envía algún objeto distinto de , Messageel objeto se serializa e inserta en el cuerpo del mensaje.

Si no establece la Formatter propiedad antes de llamar a Send(Object), el formateador tiene como valor predeterminado XmlMessageFormatter.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo	Disponible
Equipo local	Sí
Equipo local y nombre de formato directo	Sí
Equipo remoto	No
Equipo remoto y nombre de formato directo	Sí

Consulte también

Se aplica a

Send(Object, String)

Envía un objeto a la cola no transaccional a la que hace referencia este objeto MessageQueue y especifica una etiqueta para el mensaje.

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

obj: Object

Objeto que se va a enviar a la cola.

label: String

Etiqueta del mensaje.

Excepciones

ArgumentNullException

El parámetro label es null.

MessageQueueException

No se ha establecido el valor de la propiedad Path.

o bien

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En el siguiente ejemplo de código se muestra el 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");

Comentarios

Use esta sobrecarga para enviar un mensaje que contenga el obj parámetro a la cola a la que hace referencia .MessageQueue Con esta sobrecarga, puede especificar la etiqueta de cadena que identifica el mensaje. El objeto que envía a la cola puede ser , una Messageestructura, un objeto de datos o cualquier objeto administrado. Si envía algún objeto distinto de , Messageel objeto se serializa e inserta en el cuerpo del mensaje.

La etiqueta de mensaje es distinta de la etiqueta de cola de mensajes, pero ambas dependen de la aplicación y no tienen ningún significado heredado para Message Queuing.

Si usa esta sobrecarga para enviar un mensaje a una cola transaccional, el mensaje se enviará a la cola de mensajes fallidos. Si desea que el mensaje forme parte de una transacción que contenga otros mensajes, use una sobrecarga que toma o MessageQueueTransaction MessageQueueTransactionType como parámetro.

La Path propiedad de esta MessageQueue instancia debe especificarse antes de enviar el mensaje. Si no establece la Formatter propiedad antes de llamar a Send(Object), el formateador tiene como valor predeterminado .XmlMessageFormatter

La DefaultPropertiesToSend propiedad se aplica a cualquier objeto que no sea .Message Si especifica, por ejemplo, una etiqueta o una prioridad mediante el DefaultPropertiesToSend miembro , estos valores se aplican a cualquier mensaje que contenga un objeto que no sea de tipo Message cuando la aplicación la envía a la cola. Al enviar un Message, los valores de propiedad establecidos para la Message propiedad tienen prioridad sobre DefaultPropertiesToSend y la propiedad del Message.Formatter mensaje tiene prioridad sobre la propiedad de MessageQueue.Formatter la cola.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo	Disponible
Equipo local	Sí
Equipo local y nombre de formato directo	Sí
Equipo remoto	No
Equipo remoto y nombre de formato directo	Sí

Consulte también

Se aplica a

Send(Object, String, MessageQueueTransaction)

Envía un objeto a la cola transaccional a la que hace referencia este objeto MessageQueue y especifica una etiqueta para el mensaje.

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

obj: Object

Objeto que se va a enviar a la cola.

label: String

Etiqueta del mensaje.

transaction: MessageQueueTransaction

Objeto MessageQueueTransaction.

Excepciones

ArgumentNullException

El parámetro label es null.

o bien

El parámetro transaction es null.

MessageQueueException

No se ha establecido el valor de la propiedad Path.

o bien

La aplicación de Message Queuing indicó un uso incorrecto de la transacción.

o bien

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En el siguiente ejemplo de código se muestra el 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();
}

Comentarios

Use esta sobrecarga para enviar un mensaje que contenga el obj parámetro a la cola transaccional a la que hace referencia , MessageQueuemediante un contexto de transacción interno definido por el transaction parámetro . Con esta sobrecarga, puede especificar la etiqueta de cadena que identifica el mensaje. El objeto que envía a la cola puede ser , una Messageestructura, un objeto de datos o cualquier objeto administrado. Si envía algún objeto distinto de , Messageel objeto se serializa e inserta en el cuerpo del mensaje.

La etiqueta de mensaje es distinta de la etiqueta de cola de mensajes, pero ambas dependen de la aplicación y no tienen ningún significado heredado para Message Queuing.

Si usa esta sobrecarga para enviar un mensaje a una cola no transaccional, es posible que el mensaje se envíe a la cola de mensajes fallidos sin iniciar una excepción.

Si no establece la Formatter propiedad antes de llamar a Send(Object), el formateador tiene como valor predeterminado .XmlMessageFormatter

La DefaultPropertiesToSend propiedad se aplica a cualquier objeto que no sea .Message Si especifica, por ejemplo, una etiqueta o una prioridad mediante el DefaultPropertiesToSend miembro , estos valores se aplican a cualquier mensaje que contenga un objeto que no sea de tipo Message cuando la aplicación la envía a la cola. Al enviar un Message, los valores de propiedad establecidos para la Message propiedad tienen prioridad sobre DefaultPropertiesToSend y la propiedad del Message.Formatter mensaje tiene prioridad sobre la propiedad de MessageQueue.Formatter la cola.

MessageQueueTransaction es compatible con el departamento de subprocesos, por lo que si el estado del apartamento es STA, no puede usar la transacción en varios subprocesos. Visual Basic establece el estado del subproceso STAprincipal en , por lo que debe aplicar en MTAThreadAttribute la Main subrutina. De lo contrario, al enviar un mensaje transaccional mediante otro subproceso se producirá una excepción MessageQueueException. El elemento MTAThreadAttribute se aplica mediante el fragmento siguiente.

<System.MTAThreadAttribute>
 public sub Main()

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo	Disponible
Equipo local	Sí
Equipo local y nombre de formato directo	Sí
Equipo remoto	No
Equipo remoto y nombre de formato directo	Sí

Consulte también

Se aplica a

Send(Object, String, MessageQueueTransactionType)

Envía un objeto a la cola a la que hace referencia esta MessageQueue y especifica una etiqueta para el mensaje.

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

obj: Object

Objeto que se va a enviar a la cola.

label: String

Etiqueta del mensaje.

transactionType: MessageQueueTransactionType

Uno de los valores de MessageQueueTransactionType, que describe el tipo de contexto de transacción que se va a asociar al mensaje.

Excepciones

ArgumentNullException

El parámetro label es null.

MessageQueueTransaction

La aplicación de Message Queuing indicó un uso incorrecto de la transacción.

InvalidEnumArgumentException

El parámetro transactionType no es un miembro de MessageQueueTransactionType.

MessageQueueException

No se ha establecido el valor de la propiedad Path.

o bien

Error al obtener acceso a un método de Message Queuing.

Ejemplos

En el siguiente ejemplo de código se muestra el 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);

Comentarios

Use esta sobrecarga para enviar un mensaje que contenga el obj parámetro a la cola a la que hace referencia , MessageQueuemediante un contexto de transacción definido por el transactionType parámetro . Especifique Automatic para el transactionType parámetro si ya hay un contexto de transacción externo asociado al subproceso que desea usar para enviar el mensaje. Especifique Single si desea enviar el mensaje como una única transacción interna. Puede especificar None si desea enviar un mensaje transaccional a un subproceso no transaccional.

El objeto que envía a la cola puede ser o Message cualquier objeto administrado. Si envía algún objeto distinto de , Messageel objeto se serializa e inserta en el cuerpo del mensaje. Con esta sobrecarga, puede especificar la etiqueta de cadena que identifica el mensaje.

La etiqueta de mensaje es distinta de la etiqueta de cola de mensajes, pero ambas dependen de la aplicación y no tienen ningún significado heredado para Message Queuing.

Si no establece la Formatter propiedad antes de llamar a Send(Object), el formateador tiene como valor predeterminado .XmlMessageFormatter

La DefaultPropertiesToSend propiedad se aplica a cualquier objeto que no sea .Message Si especifica, por ejemplo, una etiqueta o una prioridad mediante el DefaultPropertiesToSend miembro , estos valores se aplican a cualquier mensaje que contenga un objeto que no sea de tipo Message cuando la aplicación la envía a la cola. Al enviar un Message, los valores de propiedad establecidos para tienen Message prioridad sobre DefaultPropertiesToSendy la propiedad del Message.Formatter mensaje tiene prioridad sobre la propiedad de MessageQueue.Formatter la cola.

En la tabla siguiente se muestra si este método está disponible en varios modos de grupo de trabajo.

Modo de grupo de trabajo	Disponible
Equipo local	Sí
Equipo local y nombre de formato directo	Sí
Equipo remoto	No
Equipo remoto y nombre de formato directo	Sí

Consulte también

Se aplica a

Compartir a través de

MessageQueue.Send Método

Definición

Sobrecargas

Send(Object)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Send(Object, MessageQueueTransaction)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Send(Object, MessageQueueTransactionType)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Send(Object, String)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Send(Object, String, MessageQueueTransaction)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Send(Object, String, MessageQueueTransactionType)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Recursos adicionales