MessageQueue.Send Metodo

Definizione

Spazio dei nomi:

System.Messaging

Assembly:

System.Messaging.dll

Invia un oggetto a una coda.

Overload

Send(Object)	Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento.
Send(Object, MessageQueueTransaction)	Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento.
Send(Object, MessageQueueTransactionType)	Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento.
Send(Object, String)	Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.
Send(Object, String, MessageQueueTransaction)	Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.
Send(Object, String, MessageQueueTransactionType)	Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.

Send(Object)

Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento.

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

public void Send (object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

Parametri

obj

Object

Oggetto da inviare alla coda.

Eccezioni

MessageQueueException

La proprietà Path non è stata impostata.

-oppure-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.

Esempio

L'esempio di codice seguente si connette a una coda di messaggi e invia un messaggio alla coda.

#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

Nell'esempio di codice seguente viene inviata una classe definita dall'applicazione Order a una coda e quindi viene ricevuto un messaggio da tale coda.

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda a cui fa riferimento l'oggetto MessageQueue. L'oggetto inviato alla coda può essere un Message oggetto o qualsiasi oggetto gestito. Se si invia un oggetto diverso da Message, l'oggetto viene serializzato e inserito nel corpo del messaggio.

Se si usa questo overload per inviare un messaggio a una coda transazionale, il messaggio verrà inviato alla coda dei messaggi non recapitabili. Se si desidera che il messaggio faccia parte di una transazione che contiene altri messaggi, usare un overload che accetta un oggetto MessageQueueTransaction o MessageQueueTransactionType come parametro.

Se non si imposta la proprietà prima di Formatter chiamare Send(Object), per impostazione predefinita il formattatore viene impostato su XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso da un oggetto Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio contenente un oggetto che non è di tipo Message quando l'applicazione lo invia alla coda. Quando si invia un Messageoggetto , i valori delle proprietà impostati per la Message precedenza DefaultPropertiesToSend e la proprietà del Message.Formatter messaggio ha la precedenza sulla proprietà della MessageQueue.Formatter coda.

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Modalità gruppo di lavoro	Disponibile
Computer locale	Sì
Computer locale e nome del formato diretto	Sì
Computer remoto	No
Nome del formato diretto e del computer remoto	Sì

Vedi anche

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

Send(Object, MessageQueueTransaction)

Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento.

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)

Parametri

obj

Object

Oggetto da inviare alla coda.

transaction

MessageQueueTransaction

Oggetto MessageQueueTransaction.

Eccezioni

ArgumentNullException

Il valore del parametro transaction è null.

MessageQueueException

La proprietà Path non è stata impostata.

-oppure-

Nell'applicazione Accodamento messaggi è stato segnalato un utilizzo non corretto delle transazioni.

-oppure-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.

Esempio

Nell'esempio di codice seguente viene inviata una stringa a una coda transazionale e quindi viene ricevuto un messaggio da tale coda.

#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

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda transazionale a cui fa riferimento l'oggetto MessageQueueutilizzando un contesto di transazione interno definito dal transaction parametro . L'oggetto inviato alla coda può essere un Message oggetto o qualsiasi oggetto gestito. Se si invia un oggetto diverso da Message, l'oggetto viene serializzato e inserito nel corpo del messaggio.

Se si usa questo overload per inviare un messaggio a una coda non transazionale, il messaggio potrebbe essere inviato alla coda dei messaggi non recapitabili senza generare un'eccezione.

Se non si imposta la proprietà prima di Formatter chiamare Send(Object), per impostazione predefinita il formattatore viene impostato su XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso da un oggetto Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio contenente un oggetto che non è di tipo Message quando l'applicazione lo invia alla coda. Quando si invia un Messageoggetto , i valori delle proprietà impostati per la Message precedenza DefaultPropertiesToSend e la proprietà del Message.Formatter messaggio ha la precedenza sulla proprietà della MessageQueue.Formatter coda.

MessageQueueTransaction è compatibile con apartment di threading, quindi se lo stato dell'apartment è STA, non è possibile usare la transazione in più thread. Visual Basic imposta lo stato del thread principale su STA, quindi è necessario applicare nella MTAThreadAttributeMain subroutine. In caso contrario, l'invio di un messaggio transazionale mediante un altro thread genererà un'eccezione MessageQueueException. L'oggetto MTAThreadAttribute viene applicato usando il frammento seguente.

<System.MTAThreadAttribute>
 public sub Main()

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Modalità gruppo di lavoro	Disponibile
Computer locale	Sì
Computer locale e nome del formato diretto	Sì
Computer remoto	No
Nome del formato diretto e del computer remoto	Sì

Vedi anche

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

Send(Object, MessageQueueTransactionType)

Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento.

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)

Parametri

obj

Object

Oggetto da inviare alla coda.

transactionType

MessageQueueTransactionType

Uno dei valori di MessageQueueTransactionType che descrive il tipo di contesto di transazione da associare al messaggio.

Eccezioni

InvalidEnumArgumentException

Il parametro transactionType non è uno dei membri di MessageQueueTransactionType.

MessageQueueException

La proprietà Path non è stata impostata.

-oppure-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.

Esempio

L'esempio di codice seguente illustra l'uso di 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);

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda a cui fa riferimento , MessageQueueusando un contesto di transazione definito dal transactionType parametro . Specificare Automatic per il transactionType parametro se è già presente un contesto di transazione esterno collegato al thread che si vuole usare per inviare il messaggio. Specificare Single se si desidera inviare il messaggio come singola transazione interna. È possibile specificare None se si desidera inviare un messaggio transazionale a un thread non transazionale.

L'oggetto inviato alla coda può essere un Message oggetto o qualsiasi oggetto gestito. Se si invia un oggetto diverso da Message, l'oggetto viene serializzato e inserito nel corpo del messaggio.

Se non si imposta la proprietà prima di Formatter chiamare Send(Object), per impostazione predefinita il formattatore viene impostato su XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso da un oggetto Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio contenente un oggetto che non è di tipo Message quando l'applicazione lo invia alla coda. Quando si invia un Messageoggetto , i valori delle proprietà impostati per la Message precedenza DefaultPropertiesToSend e la proprietà del Message.Formatter messaggio ha la precedenza sulla proprietà della MessageQueue.Formatter coda.

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Modalità gruppo di lavoro	Disponibile
Computer locale	Sì
Computer locale e nome del formato diretto	Sì
Computer remoto	No
Nome del formato diretto e del computer remoto	Sì

Vedi anche

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

Send(Object, String)

Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.

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)

Parametri

obj

Object

Oggetto da inviare alla coda.

label

String

L'etichetta del messaggio.

Eccezioni

ArgumentNullException

Il valore del parametro label è null.

MessageQueueException

La proprietà Path non è stata impostata.

-oppure-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.

Esempio

L'esempio di codice seguente illustra l'uso di 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");

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda a cui fa riferimento l'oggetto MessageQueue. Con questo overload, è possibile specificare l'etichetta stringa che identifica il messaggio. L'oggetto inviato alla coda può essere , Messageuna struttura, un oggetto dati o qualsiasi oggetto gestito. Se si invia un oggetto diverso da Message, l'oggetto viene serializzato e inserito nel corpo del messaggio.

L'etichetta del messaggio è distinta dall'etichetta della coda di messaggi, ma entrambe sono dipendenti dall'applicazione e non hanno alcun significato per Accodamento messaggi.

Se si usa questo overload per inviare un messaggio a una coda transazionale, il messaggio verrà inviato alla coda dei messaggi non recapitabili. Se si desidera che il messaggio faccia parte di una transazione che contiene altri messaggi, usare un overload che accetta un oggetto MessageQueueTransaction o MessageQueueTransactionType come parametro.

Prima Path di inviare il messaggio, è necessario specificare la proprietà per questa MessageQueue istanza. Se non si imposta la proprietà prima di Formatter chiamare Send(Object), per impostazione predefinita il formattatore viene impostato su XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso da un oggetto Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio contenente un oggetto che non è di tipo Message quando l'applicazione lo invia alla coda. Quando si invia un Messageoggetto , i valori delle proprietà impostati per la Message precedenza DefaultPropertiesToSend e la proprietà del Message.Formatter messaggio ha la precedenza sulla proprietà della MessageQueue.Formatter coda.

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Modalità gruppo di lavoro	Disponibile
Computer locale	Sì
Computer locale e nome del formato diretto	Sì
Computer remoto	No
Nome del formato diretto e del computer remoto	Sì

Vedi anche

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

Send(Object, String, MessageQueueTransaction)

Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.

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)

Parametri

obj

Object

Oggetto da inviare alla coda.

label

String

L'etichetta del messaggio.

transaction

MessageQueueTransaction

Oggetto MessageQueueTransaction.

Eccezioni

ArgumentNullException

Il valore del parametro label è null.

-oppure-

Il valore del parametro transaction è null.

MessageQueueException

La proprietà Path non è stata impostata.

-oppure-

Nell'applicazione Accodamento messaggi è stato segnalato un utilizzo non corretto delle transazioni.

-oppure-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.

Esempio

L'esempio di codice seguente illustra l'uso di 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();
}

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda transazionale a cui fa riferimento l'oggetto MessageQueueutilizzando un contesto di transazione interno definito dal transaction parametro . Con questo overload, è possibile specificare l'etichetta stringa che identifica il messaggio. L'oggetto inviato alla coda può essere , Messageuna struttura, un oggetto dati o qualsiasi oggetto gestito. Se si invia un oggetto diverso da Message, l'oggetto viene serializzato e inserito nel corpo del messaggio.

L'etichetta del messaggio è distinta dall'etichetta della coda di messaggi, ma entrambe sono dipendenti dall'applicazione e non hanno alcun significato per Accodamento messaggi.

Se si usa questo overload per inviare un messaggio a una coda non transazionale, il messaggio potrebbe essere inviato alla coda dei messaggi non recapitabili senza generare un'eccezione.

Se non si imposta la proprietà prima di Formatter chiamare Send(Object), per impostazione predefinita il formattatore viene impostato su XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso da un oggetto Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio contenente un oggetto che non è di tipo Message quando l'applicazione lo invia alla coda. Quando si invia un Messageoggetto , i valori delle proprietà impostati per la Message precedenza DefaultPropertiesToSend e la proprietà del Message.Formatter messaggio ha la precedenza sulla proprietà della MessageQueue.Formatter coda

MessageQueueTransaction è compatibile con apartment di threading, quindi se lo stato dell'apartment è STA, non è possibile usare la transazione in più thread. Visual Basic imposta lo stato del thread principale su STA, quindi è necessario applicare nella MTAThreadAttributeMain subroutine. In caso contrario, l'invio di un messaggio transazionale mediante un altro thread genererà un'eccezione MessageQueueException. L'oggetto MTAThreadAttribute viene applicato usando il frammento seguente.

<System.MTAThreadAttribute>
 public sub Main()

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Modalità gruppo di lavoro	Disponibile
Computer locale	Sì
Computer locale e nome del formato diretto	Sì
Computer remoto	No
Nome del formato diretto e del computer remoto	Sì

Vedi anche

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

Send(Object, String, MessageQueueTransactionType)

Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.

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)

Parametri

obj

Object

Oggetto da inviare alla coda.

label

String

L'etichetta del messaggio.

transactionType

MessageQueueTransactionType

Uno dei valori di MessageQueueTransactionType che descrive il tipo di contesto di transazione da associare al messaggio.

Eccezioni

ArgumentNullException

Il valore del parametro label è null.

MessageQueueTransaction

Nell'applicazione Accodamento messaggi è stato segnalato un utilizzo non corretto delle transazioni.

InvalidEnumArgumentException

Il parametro transactionType non è uno dei membri di MessageQueueTransactionType.

MessageQueueException

La proprietà Path non è stata impostata.

-oppure-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.

Esempio

L'esempio di codice seguente illustra l'uso di 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);

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda a cui fa riferimento , MessageQueueusando un contesto di transazione definito dal transactionType parametro . Specificare Automatic per il transactionType parametro se è già presente un contesto di transazione esterno collegato al thread che si vuole usare per inviare il messaggio. Specificare Single se si desidera inviare il messaggio come singola transazione interna. È possibile specificare None se si desidera inviare un messaggio transazionale a un thread non transazionale.

L'oggetto inviato alla coda può essere un Message oggetto o qualsiasi oggetto gestito. Se si invia un oggetto diverso da Message, l'oggetto viene serializzato e inserito nel corpo del messaggio. Con questo overload, è possibile specificare l'etichetta stringa che identifica il messaggio.

L'etichetta del messaggio è distinta dall'etichetta della coda di messaggi, ma entrambe sono dipendenti dall'applicazione e non hanno alcun significato per Accodamento messaggi.

Se non si imposta la proprietà prima di Formatter chiamare Send(Object), per impostazione predefinita il formattatore viene impostato su XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso da un oggetto Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio contenente un oggetto che non è di tipo Message quando l'applicazione lo invia alla coda. Quando si invia un Messageoggetto , i valori delle proprietà impostati per hanno la Message precedenza su DefaultPropertiesToSende la proprietà del Message.Formatter messaggio ha la precedenza sulla proprietà della MessageQueue.Formatter coda.

Nella tabella seguente viene illustrato se questo metodo è disponibile in varie modalità gruppo di lavoro.

Modalità gruppo di lavoro	Disponibile
Computer locale	Sì
Computer locale e nome del formato diretto	Sì
Computer remoto	No
Nome del formato diretto e del computer remoto	Sì

Vedi anche

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