Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo MessageQueue.Send (Object, MessageQueueTransaction)

 

Data di pubblicazione: ottobre 2016

Invia un oggetto nella coda transazionale a cui fa riferimento MessageQueue.

Spazio dei nomi:   System.Messaging
Assembly:  System.Messaging (in System.Messaging.dll)

public void Send(
	object obj,
	MessageQueueTransaction transaction
)

Parametri

obj
Type: System.Object

Oggetto da inviare alla coda.

transaction
Type: System.Messaging.MessageQueueTransaction

Oggetto MessageQueueTransaction.

Exception Condition
ArgumentNullException

Il valore del parametro transaction è null.

MessageQueueException

Il Path proprietà non è stata impostata.

-oppure-

L'applicazione di Accodamento messaggi di stato segnalato un utilizzo non corretto delle transazioni.

-oppure-

Si è verificato un errore quando si accede a un metodo di Accodamento messaggi.

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

Se si utilizza 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 Formatter proprietà prima di chiamare Send(Object), il formattatore verrà impostato per il XmlMessageFormatter.

Il DefaultPropertiesToSend proprietà si applica a qualsiasi oggetto diverso da un Message. Se si specifica, ad esempio, un'etichetta o una priorità con il DefaultPropertiesToSend membro, questi valori verranno applicati a qualsiasi messaggio contenente un oggetto che non è di tipo Message quando l'applicazione invia alla coda. Quando si invia un Message, impostare i valori delle proprietà per il Message hanno la precedenza su DefaultPropertiesToSend e il messaggio Message.Formatter avrà la precedenza sulla coda MessageQueue.Formatter proprietà.

[Visual Basic]

MessageQueueTransaction il threading apartment, pertanto se lo stato di apartment è STA, è possibile utilizzare la transazione in più thread. Visual Basic imposta lo stato del thread principale di STA, pertanto è necessario applicare il MTAThreadAttribute nel Main subroutine. In caso contrario, l'invio di un messaggio transazionale mediante un altro thread genererà un'eccezione MessageQueueException. Si applica il MTAThreadAttribute utilizzando il seguente frammento.

<System.MTAThreadAttribute>
 public sub Main()

Nella tabella seguente indica se questo metodo è disponibile in diverse modalità gruppo di lavoro.

Modalità gruppo di lavoro

Disponibile

Computer locale

Computer locale e il nome di formato direct

Computer remoto

No

Computer remoto e il nome di formato direct

Esempio di codice seguente invia una stringa a una coda transazionale e quindi viene ricevuto un messaggio dalla coda.

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;
        }
    }
}

.NET Framework
Disponibile da 1.1
Torna all'inizio
Mostra: