MessageQueue.Send Méthode

Définition

Espace de noms:

System.Messaging

Assembly:

System.Messaging.dll

Envoie un objet dans la file d'attente.

Surcharges

Send(Object)	Envoie un objet à la file d'attente non transactionnelle référencée par ce MessageQueue.
Send(Object, MessageQueueTransaction)	Envoie un objet à la file d'attente transactionnelle référencée par ce MessageQueue.
Send(Object, MessageQueueTransactionType)	Envoie un objet à la file d'attente référencée par ce MessageQueue.
Send(Object, String)	Envoie un objet à la file d'attente non transactionnelle référencée par ce MessageQueue et spécifie une étiquette pour le message.
Send(Object, String, MessageQueueTransaction)	Envoie un objet à la file d'attente transactionnelle référencée par ce MessageQueue et spécifie une étiquette pour le message.
Send(Object, String, MessageQueueTransactionType)	Envoie un objet à la file d'attente référencée par ce MessageQueue et spécifie une étiquette pour le message.

Send(Object)

Envoie un objet à la file d'attente non transactionnelle référencée par ce MessageQueue.

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

public void Send (object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

Paramètres

obj

Object

Objet à envoyer à la file d'attente.

Exceptions

MessageQueueException

La propriété Path n'a pas été définie.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant se connecte à une file d’attente de messages et envoie un message à la file d’attente.

#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

L’exemple de code suivant envoie une classe définie par Order l’application à une file d’attente, puis reçoit un message de cette file d’attente.

Remarques

Utilisez cette surcharge pour envoyer un message qui contient le obj paramètre à la file d’attente référencée par le MessageQueue. L’objet que vous envoyez à la file d’attente peut être un Message ou n’importe quel objet managé. Si vous envoyez un objet autre qu’un Message, l’objet est sérialisé et inséré dans le corps du message.

Si vous utilisez cette surcharge pour envoyer un message à une file d’attente transactionnelle, le message est envoyé à la file d’attente de lettres mortes. Si vous souhaitez que le message fait partie d’une transaction qui contient d’autres messages, utilisez une surcharge qui prend un MessageQueueTransaction ou MessageQueueTransactionType comme paramètre.

Si vous ne définissez pas la Formatter propriété avant d’appeler Send(Object), le formateur est défini par défaut sur XmlMessageFormatter.

La DefaultPropertiesToSend propriété s’applique à tout objet autre qu’un Message. Si vous spécifiez, par exemple, une étiquette ou une priorité à l’aide du DefaultPropertiesToSend membre, ces valeurs s’appliquent à tout message qui contient un objet qui n’est pas de type Message lorsque votre application l’envoie à la file d’attente. Lors de l’envoi d’un Message, les valeurs de propriété définies pour le Message sont prioritaires sur DefaultPropertiesToSend et la propriété du Message.Formatter message est prioritaire sur la propriété de MessageQueue.Formatter la file d’attente.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

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

Send(Object, MessageQueueTransaction)

Envoie un objet à la file d'attente transactionnelle référencée par ce 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)

Paramètres

obj

Object

Objet à envoyer à la file d'attente.

transaction

MessageQueueTransaction

Objet MessageQueueTransaction.

Exceptions

ArgumentNullException

Le paramètre transaction a la valeur null.

MessageQueueException

La propriété Path n'a pas été définie.

- ou -

L'application Message Queuing a signalé une utilisation erronée de la transaction.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant envoie une chaîne à une file d’attente transactionnelle, puis reçoit un message de cette file d’attente.

#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

Remarques

Utilisez cette surcharge pour envoyer un message qui contient le obj paramètre à la file d’attente transactionnelle référencée par , à l’aide MessageQueued’un contexte de transaction interne défini par le transaction paramètre . L’objet que vous envoyez à la file d’attente peut être un Message ou n’importe quel objet managé. Si vous envoyez un objet autre qu’un Message, l’objet est sérialisé et inséré dans le corps du message.

Si vous utilisez cette surcharge pour envoyer un message à une file d’attente non transactionnelle, le message peut être envoyé à la file d’attente de lettres mortes sans lever d’exception.

Si vous ne définissez pas la Formatter propriété avant d’appeler Send(Object), le formateur est défini par défaut sur XmlMessageFormatter.

La DefaultPropertiesToSend propriété s’applique à tout objet autre qu’un Message. Si vous spécifiez, par exemple, une étiquette ou une priorité à l’aide du DefaultPropertiesToSend membre, ces valeurs s’appliquent à tout message qui contient un objet qui n’est pas de type Message lorsque votre application l’envoie à la file d’attente. Lors de l’envoi d’un Message, les valeurs de propriété définies pour le Message sont prioritaires sur DefaultPropertiesToSend et la propriété du Message.Formatter message est prioritaire sur la propriété de MessageQueue.Formatter la file d’attente.

MessageQueueTransaction est compatible avec l’appartement de threads. Par conséquent, si votre état d’appartement est STA, vous ne pouvez pas utiliser la transaction dans plusieurs threads. Visual Basic définit l’état du thread main sur STA, vous devez donc appliquer dans MTAThreadAttribute la Main sous-routine. Sinon, l'envoi d'un message transactionnel qui utilise un autre thread lève une exception MessageQueueException. Vous appliquez le MTAThreadAttribute en utilisant le fragment suivant.

<System.MTAThreadAttribute>
 public sub Main()

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

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

Send(Object, MessageQueueTransactionType)

Envoie un objet à la file d'attente référencée par ce 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)

Paramètres

obj

Object

Objet à envoyer à la file d'attente.

transactionType

MessageQueueTransactionType

Une des valeurs de MessageQueueTransactionType décrivant le type de contexte de transaction à associer au message.

Exceptions

InvalidEnumArgumentException

Le paramètre transactionType ne fait pas partie des membres MessageQueueTransactionType.

MessageQueueException

La propriété Path n'a pas été définie.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L'exemple de code suivant montre l'utilisation 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);

Remarques

Utilisez cette surcharge pour envoyer un message qui contient le obj paramètre à la file d’attente référencée par , à l’aide MessageQueued’un contexte de transaction défini par le transactionType paramètre . Spécifiez Automatic pour le transactionType paramètre s’il existe déjà un contexte de transaction externe attaché au thread que vous souhaitez utiliser pour envoyer le message. Spécifiez Single si vous souhaitez envoyer le message en tant que transaction interne unique. Vous pouvez spécifier None si vous souhaitez envoyer un message transactionnel à un thread non transactionnel.

L’objet que vous envoyez à la file d’attente peut être un Message ou n’importe quel objet managé. Si vous envoyez un objet autre qu’un Message, l’objet est sérialisé et inséré dans le corps du message.

Si vous ne définissez pas la Formatter propriété avant d’appeler Send(Object), le formateur est défini par défaut sur XmlMessageFormatter.

La DefaultPropertiesToSend propriété s’applique à tout objet autre qu’un Message. Si vous spécifiez, par exemple, une étiquette ou une priorité à l’aide du DefaultPropertiesToSend membre, ces valeurs s’appliquent à tout message qui contient un objet qui n’est pas de type Message lorsque votre application l’envoie à la file d’attente. Lors de l’envoi d’un Message, les valeurs de propriété définies pour le Message sont prioritaires sur DefaultPropertiesToSend et la propriété du Message.Formatter message est prioritaire sur la propriété de MessageQueue.Formatter la file d’attente.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

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

Send(Object, String)

Envoie un objet à la file d'attente non transactionnelle référencée par ce MessageQueue et spécifie une étiquette pour le 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)

Paramètres

obj

Object

Objet à envoyer à la file d'attente.

label

String

Étiquette du message.

Exceptions

ArgumentNullException

Le paramètre label a la valeur null.

MessageQueueException

La propriété Path n'a pas été définie.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L'exemple de code suivant montre l'utilisation 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");

Remarques

Utilisez cette surcharge pour envoyer un message qui contient le obj paramètre à la file d’attente référencée par .MessageQueue Avec cette surcharge, vous pouvez spécifier l’étiquette de chaîne qui identifie le message. L’objet que vous envoyez à la file d’attente peut être un Message, une structure, un objet de données ou n’importe quel objet managé. Si vous envoyez un autre objet qu’un Message, l’objet est sérialisé et inséré dans le corps du message.

L’étiquette de message est distincte de l’étiquette de file d’attente de messages, mais toutes deux dépendent de l’application et n’ont pas de signification héritée pour Message Queuing.

Si vous utilisez cette surcharge pour envoyer un message à une file d’attente transactionnelle, le message est envoyé à la file d’attente de lettres mortes. Si vous souhaitez que le message fait partie d’une transaction qui contient d’autres messages, utilisez une surcharge qui prend un MessageQueueTransaction ou MessageQueueTransactionType comme paramètre.

La Path propriété de cette MessageQueue instance doit être spécifiée avant d’envoyer le message. Si vous ne définissez pas la Formatter propriété avant d’appeler Send(Object), le formateur est par défaut le XmlMessageFormatter.

La DefaultPropertiesToSend propriété s’applique à tout objet autre qu’un Messageobjet . Si vous spécifiez, par exemple, une étiquette ou une priorité à l’aide du DefaultPropertiesToSend membre, ces valeurs s’appliquent à tout message qui contient un objet qui n’est pas de type Message lorsque votre application l’envoie à la file d’attente. Lors de l’envoi d’un Message, les valeurs de propriété définies pour le Message sont prioritaires sur DefaultPropertiesToSend et la propriété du Message.Formatter message est prioritaire sur la propriété de MessageQueue.Formatter la file d’attente.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

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

Send(Object, String, MessageQueueTransaction)

Envoie un objet à la file d'attente transactionnelle référencée par ce MessageQueue et spécifie une étiquette pour le 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)

Paramètres

obj

Object

Objet à envoyer à la file d'attente.

label

String

Étiquette du message.

transaction

MessageQueueTransaction

Objet MessageQueueTransaction.

Exceptions

ArgumentNullException

Le paramètre label a la valeur null.

- ou -

Le paramètre transaction a la valeur null.

MessageQueueException

La propriété Path n'a pas été définie.

- ou -

L'application Message Queuing a signalé une utilisation erronée de la transaction.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L'exemple de code suivant montre l'utilisation 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();
}

Remarques

Utilisez cette surcharge pour envoyer un message qui contient le obj paramètre à la file d’attente transactionnelle référencée par , à l’aide MessageQueued’un contexte de transaction interne défini par le transaction paramètre. Avec cette surcharge, vous pouvez spécifier l’étiquette de chaîne qui identifie le message. L’objet que vous envoyez à la file d’attente peut être un Message, une structure, un objet de données ou n’importe quel objet managé. Si vous envoyez un autre objet qu’un Message, l’objet est sérialisé et inséré dans le corps du message.

L’étiquette de message est distincte de l’étiquette de file d’attente de messages, mais toutes deux dépendent de l’application et n’ont pas de signification héritée pour Message Queuing.

Si vous utilisez cette surcharge pour envoyer un message à une file d’attente non transactionnelle, le message peut être envoyé à la file d’attente de lettres mortes sans lever d’exception.

Si vous ne définissez pas la Formatter propriété avant d’appeler Send(Object), le formateur est par défaut le XmlMessageFormatter.

La DefaultPropertiesToSend propriété s’applique à tout objet autre qu’un Messageobjet . Si vous spécifiez, par exemple, une étiquette ou une priorité à l’aide du DefaultPropertiesToSend membre, ces valeurs s’appliquent à tout message qui contient un objet qui n’est pas de type Message lorsque votre application l’envoie à la file d’attente. Lors de l’envoi d’un Message, les valeurs de propriété définies pour la Message priorité sur DefaultPropertiesToSend et la propriété du Message.Formatter message est prioritaire sur la propriété de MessageQueue.Formatter la file d’attente

MessageQueueTransaction est threading apartment aware, donc si votre état d’appartement est STA, vous ne pouvez pas utiliser la transaction dans plusieurs threads. Visual Basic définit l’état du thread main sur STA, vous devez donc appliquer le MTAThreadAttribute dans la Main sous-routine. Sinon, l'envoi d'un message transactionnel qui utilise un autre thread lève une exception MessageQueueException. Vous appliquez le MTAThreadAttribute en utilisant le fragment suivant.

<System.MTAThreadAttribute>
 public sub Main()

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

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

Send(Object, String, MessageQueueTransactionType)

Envoie un objet à la file d'attente référencée par ce MessageQueue et spécifie une étiquette pour le 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)

Paramètres

obj

Object

Objet à envoyer à la file d'attente.

label

String

Étiquette du message.

transactionType

MessageQueueTransactionType

Une des valeurs de MessageQueueTransactionType décrivant le type de contexte de transaction à associer au message.

Exceptions

ArgumentNullException

Le paramètre label a la valeur null.

MessageQueueTransaction

L'application Message Queuing a signalé une utilisation erronée de la transaction.

InvalidEnumArgumentException

Le paramètre transactionType ne fait pas partie des membres MessageQueueTransactionType.

MessageQueueException

La propriété Path n'a pas été définie.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L'exemple de code suivant montre l'utilisation 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);

Remarques

Utilisez cette surcharge pour envoyer un message qui contient le obj paramètre à la file d’attente référencée par , à l’aide MessageQueued’un contexte de transaction défini par le transactionType paramètre . Spécifiez Automatic pour le transactionType paramètre s’il existe déjà un contexte de transaction externe attaché au thread que vous souhaitez utiliser pour envoyer le message. Spécifiez Single si vous souhaitez envoyer le message en tant que transaction interne unique. Vous pouvez spécifier None si vous souhaitez envoyer un message transactionnel à un thread non transactionnel.

L’objet que vous envoyez à la file d’attente peut être un ou n’importe Message quel objet managé. Si vous envoyez un autre objet qu’un Message, l’objet est sérialisé et inséré dans le corps du message. Avec cette surcharge, vous pouvez spécifier l’étiquette de chaîne qui identifie le message.

L’étiquette de message est distincte de l’étiquette de file d’attente de messages, mais toutes deux dépendent de l’application et n’ont pas de signification héritée pour Message Queuing.

Si vous ne définissez pas la Formatter propriété avant d’appeler Send(Object), le formateur est par défaut le XmlMessageFormatter.

La DefaultPropertiesToSend propriété s’applique à tout objet autre qu’un Messageobjet . Si vous spécifiez, par exemple, une étiquette ou une priorité à l’aide du DefaultPropertiesToSend membre, ces valeurs s’appliquent à tout message qui contient un objet qui n’est pas de type Message lorsque votre application l’envoie à la file d’attente. Lors de l’envoi d’un Message, les valeurs de propriété définies pour le Message sont prioritaires sur DefaultPropertiesToSend, et la propriété du Message.Formatter message est prioritaire sur la propriété de MessageQueue.Formatter la file d’attente.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

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