MessageQueue.Send Metodo

Definizione

Invia un oggetto a una coda.Sends an object to a queue.

Overload

Send(Object)

Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento.Sends an object to non-transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransaction)

Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento.Sends an object to the transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransactionType)

Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento.Sends an object to the queue referenced by this MessageQueue.

Send(Object, String)

Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransaction)

Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransactionType)

Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.Sends an object to the queue referenced by this MessageQueue and specifies a label for the message.

Send(Object)

Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento.Sends an object to non-transactional queue referenced by this MessageQueue.

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

Parametri

obj
Object

Oggetto da inviare alla coda.The object to send to the queue.

Eccezioni

La proprietà Path non è stata impostata.The Path property has not been set.

-oppure--or- Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

Nell'esempio di codice seguente viene eseguita la connessione a una coda di messaggi e viene inviato un messaggio alla coda.The following code example connects to a message queue and sends a message to the queue.

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

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

      return;
   }

};

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

using System;
using System.Messaging;

namespace MyProject
{

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

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

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

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

            return;
        }


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

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

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

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

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

            return;
        }
    }
}
Imports System.Messaging

Public Class MyNewQueue


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

        Public Shared Sub Main()

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

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

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessage()

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

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

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

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

                ' Commit the transaction.
                myTransaction.Commit()

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

            Return

        End Sub

End Class

L'esempio di codice seguente invia una classe definita Order dall'applicazione a una coda e quindi riceve un messaggio da tale coda.The following code example sends an application-defined Order class to a queue and then receives a message from that queue.

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda a cui fa riferimento. MessageQueueUse this overload to send a message that contains the obj parameter to the queue referenced by the MessageQueue. L'oggetto che si invia alla coda può essere un Message o qualsiasi oggetto gestito.The object you send to the queue can be a Message or any managed object. Se si invia un Messageoggetto diverso da, l'oggetto viene serializzato e inserito nel corpo del messaggio.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

Se si utilizza questo overload per inviare un messaggio a una coda transazionale, il messaggio verrà inviato alla coda dei messaggi non recapitabili.If you use this overload to send a message to a transactional queue, the message will be sent to the dead-letter queue. Se si desidera che il messaggio faccia parte di una transazione che contiene altri messaggi, utilizzare un overload che accetta un MessageQueueTransaction oggetto MessageQueueTransactionType o come parametro.If you want the message to be part of a transaction that contains other messages, use an overload that takes a MessageQueueTransaction or MessageQueueTransactionType as a parameter.

Se non si imposta la Formatter proprietà prima di chiamare Send(Object), per impostazione predefinita il XmlMessageFormatterformattatore è.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso Messageda.The DefaultPropertiesToSend property applies to any object other than a Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio che contiene un oggetto che non è Message di tipo quando l'applicazione lo invia alla coda.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Quando si invia Messageun oggetto, i valori delle proprietà Message impostati per hanno DefaultPropertiesToSend la precedenza su e Message.Formatter la proprietà del messaggio MessageQueue.Formatter ha la precedenza sulla proprietà della coda.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Vedi anche

Send(Object, MessageQueueTransaction)

Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento.Sends an object to the transactional queue referenced by this MessageQueue.

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

Parametri

obj
Object

Oggetto da inviare alla coda.The object to send to the queue.

Eccezioni

Il valore del parametro transaction è null.The transaction parameter is null.

La proprietà Path non è stata impostata.The Path property has not been set.

-oppure--or- Nell'applicazione Accodamento messaggi è stato segnalato un utilizzo non corretto delle transazioni.The Message Queuing application indicated an incorrect transaction use.

-oppure--or- Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

Nell'esempio di codice seguente viene inviata una stringa a una coda transazionale e viene quindi ricevuto un messaggio da tale coda.The following code example sends a string to a transactional queue and then receives a message from that queue.

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

using namespace System;
using namespace System::Messaging;

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

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

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

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

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

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

      return;
   }


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

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

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

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

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

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

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

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

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

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

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

namespace MyProject
{

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

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

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

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

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


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

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

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

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

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

            return;
        }


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

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

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

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

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

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

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

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

            return;
        }
    }
}
Imports System.Messaging

   
Public Class MyNewQueue


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

        Public Shared Sub Main()

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

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

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

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessageTransactional()

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

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

                ' Begin the transaction.
                myTransaction.Begin()

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

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

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessageTransactional()

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

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

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

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

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

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

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

                End If

                ' Else catch other sources of a MessageQueueException.


                ' Roll back the transaction.
                myTransaction.Abort()


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

            End Try

            Return

        End Sub

End Class

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda transazionale a cui fa riferimento l' MessageQueueoggetto, utilizzando un contesto di transaction transazione interno definito dal parametro.Use this overload to send a message that contains the obj parameter to the transactional queue referenced by the MessageQueue, using an internal transaction context defined by the transaction parameter. L'oggetto che si invia alla coda può essere un Message o qualsiasi oggetto gestito.The object you send to the queue can be a Message or any managed object. Se si invia un Messageoggetto diverso da, l'oggetto viene serializzato e inserito nel corpo del messaggio.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

Se si utilizza questo overload per inviare un messaggio a una coda non transazionale, è possibile che il messaggio venga inviato alla coda dei messaggi non recapitabili senza generare un'eccezione.If you use this overload to send a message to a non-transactional queue, the message might be sent to the dead-letter queue without throwing an exception.

Se non si imposta la Formatter proprietà prima di chiamare Send(Object), per impostazione predefinita il XmlMessageFormatterformattatore è.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso Messageda.The DefaultPropertiesToSend property applies to any object other than a Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio che contiene un oggetto che non è Message di tipo quando l'applicazione lo invia alla coda.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Quando si invia Messageun oggetto, i valori delle proprietà Message impostati per hanno DefaultPropertiesToSend la precedenza su e Message.Formatter la proprietà del messaggio MessageQueue.Formatter ha la precedenza sulla proprietà della coda.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

MessageQueueTransactionè compatibile con l'Apartment di threading, pertanto se lo STAstato dell'Apartment è, non è possibile utilizzare la transazione in più thread.MessageQueueTransaction is threading apartment aware, so if your apartment state is STA, you cannot use the transaction in multiple threads. Visual Basic imposta lo stato del thread principale su STA, pertanto è necessario MTAThreadAttribute applicare nella Main subroutine.Visual Basic sets the state of the main thread to STA, so you must apply the MTAThreadAttribute in the Main subroutine. In caso contrario, l'invio di un messaggio transazionale mediante un altro thread genererà un'eccezione MessageQueueException.Otherwise, sending a transactional message using another thread throws a MessageQueueException exception. Per applicare l' MTAThreadAttribute oggetto, usare il frammento di codice seguente.You apply the MTAThreadAttribute by using the following fragment.

<System.MTAThreadAttribute>  
 public sub Main()  

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Vedi anche

Send(Object, MessageQueueTransactionType)

Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento.Sends an object to the queue referenced by this MessageQueue.

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

Parametri

obj
Object

Oggetto da inviare alla coda.The object to send to the queue.

transactionType
MessageQueueTransactionType

Uno dei valori di MessageQueueTransactionType che descrive il tipo di contesto di transazione da associare al messaggio.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Eccezioni

Il parametro transactionType non è uno dei membri di MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

La proprietà Path non è stata impostata.The Path property has not been set.

In alternativa-or- Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

L'esempio di codice seguente illustra l'uso di Send(Object, MessageQueueTransactionType).The following code example demonstrates the use of Send(Object, MessageQueueTransactionType).


// Connect to a transactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

queue->Close();


// Connect to a transactional queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda a cui fa riferimento MessageQueue, utilizzando un contesto di transactionType transazione definito dal parametro.Use this overload to send a message that contains the obj parameter to the queue referenced by the MessageQueue, using a transaction context defined by the transactionType parameter. Specificare Automatic per il transactionType parametro se è già presente un contesto di transazione esterno collegato al thread che si desidera utilizzare per inviare il messaggio.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to send the message. Specificare Single se si desidera inviare il messaggio come singola transazione interna.Specify Single if you want to send the message as a single internal transaction. È possibile specificare None se si desidera inviare un messaggio transazionale a un thread non transazionale.You can specify None if you want to send a transactional message to a non-transactional thread.

L'oggetto che si invia alla coda può essere un Message o qualsiasi oggetto gestito.The object you send to the queue can be a Message or any managed object. Se si invia un Messageoggetto diverso da, l'oggetto viene serializzato e inserito nel corpo del messaggio.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

Se non si imposta la Formatter proprietà prima di chiamare Send(Object), per impostazione predefinita il XmlMessageFormatterformattatore è.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso Messageda.The DefaultPropertiesToSend property applies to any object other than a Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio che contiene un oggetto che non è Message di tipo quando l'applicazione lo invia alla coda.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Quando si invia Messageun oggetto, i valori delle proprietà Message impostati per hanno DefaultPropertiesToSend la precedenza su e Message.Formatter la proprietà del messaggio MessageQueue.Formatter ha la precedenza sulla proprietà della coda.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Vedi anche

Send(Object, String)

Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the message.

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

Parametri

obj
Object

Oggetto da inviare alla coda.The object to send to the queue.

label
String

L'etichetta del messaggio.The label of the message.

Eccezioni

Il valore del parametro label è null.The label parameter is null.

La proprietà Path non è stata impostata.The Path property has not been set.

-oppure--or- Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

L'esempio di codice seguente illustra l'uso di Send(Object, String).The following code example demonstrates the use of Send(Object, String).


// Connect to a queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, "Example Message Label");

queue->Close();


// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, "Example Message Label");

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda a cui fa riferimento. MessageQueueUse this overload to send a message that contains the obj parameter to the queue referenced by the MessageQueue. Con questo overload è possibile specificare l'etichetta di stringa che identifica il messaggio.With this overload, you can specify the string label that identifies the message. L'oggetto che si invia alla coda può essere Message, una struttura, un oggetto dati o qualsiasi oggetto gestito.The object you send to the queue can be a Message, a structure, a data object, or any managed object. Se si invia un Messageoggetto diverso da, l'oggetto viene serializzato e inserito nel corpo del messaggio.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

L'etichetta del messaggio è diversa dall'etichetta della coda di messaggi, ma entrambe sono dipendenti dall'applicazione e non hanno significato di ereditarietà per l'accodamento dei messaggi.The message label is distinct from the message queue label, but both are application-dependent and have no inherit meaning to Message Queuing.

Se si utilizza questo overload per inviare un messaggio a una coda transazionale, il messaggio verrà inviato alla coda dei messaggi non recapitabili.If you use this overload to send a message to a transactional queue, the message will be sent to the dead-letter queue. Se si desidera che il messaggio faccia parte di una transazione che contiene altri messaggi, utilizzare un overload che accetta un MessageQueueTransaction oggetto MessageQueueTransactionType o come parametro.If you want the message to be part of a transaction that contains other messages, use an overload that takes a MessageQueueTransaction or MessageQueueTransactionType as a parameter.

È Path necessario specificare la MessageQueue proprietà per questa istanza prima di inviare il messaggio.The Path property for this MessageQueue instance must be specified before you send the message. Se non si imposta la Formatter proprietà prima di chiamare Send(Object), per impostazione predefinita il XmlMessageFormatterformattatore è.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso Messageda.The DefaultPropertiesToSend property applies to any object other than a Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio che contiene un oggetto che non è Message di tipo quando l'applicazione lo invia alla coda.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Quando si invia Messageun oggetto, i valori delle proprietà Message impostati per hanno DefaultPropertiesToSend la precedenza su e Message.Formatter la proprietà del messaggio MessageQueue.Formatter ha la precedenza sulla proprietà della coda.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Vedi anche

Send(Object, String, MessageQueueTransaction)

Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the message.

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

Parametri

obj
Object

Oggetto da inviare alla coda.The object to send to the queue.

label
String

L'etichetta del messaggio.The label of the message.

Eccezioni

Il valore del parametro label è null.The label parameter is null.

-oppure--or- Il valore del parametro transaction è null.The transaction parameter is null.

La proprietà Path non è stata impostata.The Path property has not been set.

-oppure--or- Nell'applicazione Accodamento messaggi è stato segnalato un utilizzo non corretto delle transazioni.The Message Queuing application indicated an incorrect transaction usage.

In alternativa-or- Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

L'esempio di codice seguente illustra l'uso di Send(Object, String, MessageQueueTransaction).The following code example demonstrates the use of Send(Object, String, MessageQueueTransaction).


// Connect to a transactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Create a message queuing transaction.
MessageQueueTransaction^ transaction = gcnew MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction->Begin();

    // Send the message to the queue.
    queue->Send(msg, "Example Message Label", transaction);

    // Commit the transaction.
    transaction->Commit();
}
catch (Exception^ ex)
{
    // Cancel the transaction.
    transaction->Abort();

    // Propagate the exception.
    throw ex;
}
finally
{
    // Dispose of the transaction object.
    delete transaction;
    queue->Close();
}


// Connect to a transactional queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Create a message queuing transaction.
MessageQueueTransaction transaction = new MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction.Begin();

    // Send the message to the queue.
    queue.Send(msg, "Example Message Label", transaction);

    // Commit the transaction.
    transaction.Commit();
}
catch(System.Exception e)
{
    // Cancel the transaction.
    transaction.Abort();

    // Propagate the exception.
    throw e;
}
finally
{
    // Dispose of the transaction object.
    transaction.Dispose();
}

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda transazionale a cui fa riferimento l' MessageQueueoggetto, utilizzando un contesto di transaction transazione interno definito dal parametro.Use this overload to send a message that contains the obj parameter to the transactional queue referenced by the MessageQueue, using an internal transaction context defined by the transaction parameter. Con questo overload è possibile specificare l'etichetta di stringa che identifica il messaggio.With this overload, you can specify the string label that identifies the message. L'oggetto che si invia alla coda può essere Message, una struttura, un oggetto dati o qualsiasi oggetto gestito.The object you send to the queue can be a Message, a structure, a data object, or any managed object. Se si invia un Messageoggetto diverso da, l'oggetto viene serializzato e inserito nel corpo del messaggio.If you send any object other than a Message, the object is serialized and inserted into the body of the message.

L'etichetta del messaggio è diversa dall'etichetta della coda di messaggi, ma entrambe sono dipendenti dall'applicazione e non hanno significato di ereditarietà per l'accodamento dei messaggi.The message label is distinct from the message queue label, but both are application-dependent and have no inherit meaning to Message Queuing.

Se si utilizza questo overload per inviare un messaggio a una coda non transazionale, è possibile che il messaggio venga inviato alla coda dei messaggi non recapitabili senza generare un'eccezione.If you use this overload to send a message to a non-transactional queue, the message might be sent to the dead-letter queue without throwing an exception.

Se non si imposta la Formatter proprietà prima di chiamare Send(Object), per impostazione predefinita il XmlMessageFormatterformattatore è.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso Messageda.The DefaultPropertiesToSend property applies to any object other than a Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio che contiene un oggetto che non è Message di tipo quando l'applicazione lo invia alla coda.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Quando si invia Messageun oggetto, i valori delle proprietà Message impostati per hanno DefaultPropertiesToSend la precedenza su e Message.Formatter la proprietà del messaggio MessageQueue.Formatter ha la precedenza sulla proprietà della codaWhen sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property

MessageQueueTransactionè compatibile con l'Apartment di threading, pertanto se lo STAstato dell'Apartment è, non è possibile utilizzare la transazione in più thread.MessageQueueTransaction is threading apartment aware, so if your apartment state is STA, you cannot use the transaction in multiple threads. Visual Basic imposta lo stato del thread principale su STA, pertanto è necessario MTAThreadAttribute applicare nella Main subroutine.Visual Basic sets the state of the main thread to STA, so you must apply the MTAThreadAttribute in the Main subroutine. In caso contrario, l'invio di un messaggio transazionale mediante un altro thread genererà un'eccezione MessageQueueException.Otherwise, sending a transactional message using another thread throws a MessageQueueException exception. Per applicare l' MTAThreadAttribute oggetto, usare il frammento di codice seguente.You apply the MTAThreadAttribute by using the following fragment.

<System.MTAThreadAttribute>  
 public sub Main()  

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Vedi anche

Send(Object, String, MessageQueueTransactionType)

Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.Sends an object to the queue referenced by this MessageQueue and specifies a label for the message.

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

Parametri

obj
Object

Oggetto da inviare alla coda.The object to send to the queue.

label
String

L'etichetta del messaggio.The label of the message.

transactionType
MessageQueueTransactionType

Uno dei valori di MessageQueueTransactionType che descrive il tipo di contesto di transazione da associare al messaggio.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Eccezioni

Il valore del parametro label è null.The label parameter is null.

Nell'applicazione Accodamento messaggi è stato segnalato un utilizzo non corretto delle transazioni.The Message Queuing application indicated an incorrect transaction usage.

Il parametro transactionType non è uno dei membri di MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

La proprietà Path non è stata impostata.The Path property has not been set.

In alternativa-or- Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

L'esempio di codice seguente illustra l'uso di Send(Object, String, MessageQueueTransactionType).The following code example demonstrates the use of Send(Object, String, MessageQueueTransactionType).


// Connect to a transactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, "Example Message Label",
    MessageQueueTransactionType::Single);

queue->Close();


// Connect to a transactional queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, "Example Message Label",
    MessageQueueTransactionType.Single);

Commenti

Utilizzare questo overload per inviare un messaggio contenente il obj parametro alla coda a cui fa riferimento MessageQueue, utilizzando un contesto di transactionType transazione definito dal parametro.Use this overload to send a message that contains the obj parameter to the queue referenced by the MessageQueue, using a transaction context defined by the transactionType parameter. Specificare Automatic per il transactionType parametro se è già presente un contesto di transazione esterno collegato al thread che si desidera utilizzare per inviare il messaggio.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to send the message. Specificare Single se si desidera inviare il messaggio come singola transazione interna.Specify Single if you want to send the message as a single internal transaction. È possibile specificare None se si desidera inviare un messaggio transazionale a un thread non transazionale.You can specify None if you want to send a transactional message to a non-transactional thread.

L'oggetto che si invia alla coda può essere un Message o qualsiasi oggetto gestito.The object you send to the queue can be a Message or any managed object. Se si invia un Messageoggetto diverso da, l'oggetto viene serializzato e inserito nel corpo del messaggio.If you send any object other than a Message, the object is serialized and inserted into the body of the message. Con questo overload è possibile specificare l'etichetta di stringa che identifica il messaggio.With this overload, you can specify the string label that identifies the message.

L'etichetta del messaggio è diversa dall'etichetta della coda di messaggi, ma entrambe sono dipendenti dall'applicazione e non hanno significato di ereditarietà per l'accodamento dei messaggi.The message label is distinct from the message queue label, but both are application-dependent and have no inherit meaning to Message Queuing.

Se non si imposta la Formatter proprietà prima di chiamare Send(Object), per impostazione predefinita il XmlMessageFormatterformattatore è.If you do not set the Formatter property before calling Send(Object), the formatter defaults to the XmlMessageFormatter.

La DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso Messageda.The DefaultPropertiesToSend property applies to any object other than a Message. Se si specifica, ad esempio, un'etichetta o una priorità usando il DefaultPropertiesToSend membro, questi valori si applicano a qualsiasi messaggio che contiene un oggetto che non è Message di tipo quando l'applicazione lo invia alla coda.If you specify, for example, a label or a priority using the DefaultPropertiesToSend member, these values apply to any message that contains an object that is not of type Message when your application sends it to the queue. Quando si invia Messageun oggetto, i valori delle proprietà Message impostati per hanno DefaultPropertiesToSendla precedenza su e la Message.Formatter proprietà del messaggio MessageQueue.Formatter ha la precedenza sulla proprietà della coda.When sending a Message, the property values set for the Message take precedence over DefaultPropertiesToSend, and the message's Message.Formatter property takes precedence over the queue's MessageQueue.Formatter property.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Vedi anche

Si applica a