Questo argomento non è stato ancora valutato - Valuta questo argomento

Classe Message

.NET Framework 3.5

Altre versioni

Aggiornamento: novembre 2007

Rappresenta l'unità di comunicazione tra endpoint in un ambiente distribuito.

Spazio dei nomi: System.ServiceModel.Channels
Assembly: System.ServiceModel (in System.ServiceModel.dll)

Sintassi

C++

public abstract class Message : IDisposable

public abstract class Message implements IDisposable

JScript

public abstract class Message implements IDisposable

Note

La classe Message consente di comunicare informazioni arbitrarie tra un mittente e un destinatario in una rete. Può essere utilizzata per inoltrare informazioni, suggerire o richiedere un intervento o richiedere dati.

La struttura di un oggetto Message rappresenta una SOAP envelope. È costituita da due parti distinte: il corpo del messaggio e un insieme di intestazioni facoltativo rappresentato dalla classe Headers. Il contenuto del messaggio sono dati definiti dall'applicazione inviati da un mittente a un destinatario. Le intestazioni del messaggio consentono all'estensibilità del sistema e dell'applicazione di soddisfare esigenze sempre nuove poiché è possibile definire codice per modificare e rispondere a intestazioni specifiche. È anche possibile definire intestazioni personalizzate. Le intestazioni del messaggio vengono serializzate o deserializzate insieme al contenuto del messaggio.

I messaggi vengono ricevuti e inviati in formati particolari. Sono supportati due formati: XML basato su testo standard e XML binario. L'oggetto Message può essere utilizzato per rappresentare entrambe le SOAP envelope 1.1 e 1.2. Dopo che è stata creata, un'istanza di Message diventa fissa ed è associata a una versione SOAP specifica. La proprietà Version rappresenta la versione SOAP del messaggio.

Un oggetto Message può essere serializzato in un archivio esterno utilizzando il metodo WriteMessage. Anche le proprietà del messaggio possono essere serializzate, ma devono essere identificate individualmente e serializzate separatamente. La deserializzazione di un messaggio per creare un oggetto Message in memoria può essere effettuata utilizzando CreateMessage. Le proprietà devono inoltre essere deserializzate individualmente e aggiunte manualmente all'insieme di proprietà dell'istanza Message specifica.

La dimensione di un oggetto Message è fissata alla dimensione dei dati che sta trasmettendo. Ogni corpo viene modellato come un'istanza di XmlReader, senza limiti predefiniti sulla dimensione del flusso del quale l'istanza XmlReader sta effettuando il wrapping. Provider di canale specifici possono tuttavia avere un limite sulla dimensione dei messaggi che elaborano.

Un oggetto Message può essere annotato con informazioni utili generate da un'entità che ha esaminato ed elaborato il messaggio. Questa funzionalità è fornita dalle proprietà Headers e Properties. L'insieme Headers rappresenta l'insieme di intestazioni SOAP nel messaggio.

La proprietà Properties rappresenta l'insieme di annotazioni a livello di elaborazione incluse nel messaggio. Poiché le informazioni incluse nelle intestazioni vengono trasmesse sulla rete, un'entità che esamina un'intestazione deve supportare le versioni sottostanti dei protocolli utilizzati dall'intestazione. Le proprietà forniscono tuttavia una modalità di annotazione dei messaggi maggiormente indipendente dalla versione.

Per creare un'istanza Message, utilizzare uno dei metodi CreateMessage.

Dopo avere terminato l'accesso al contenuto di un messaggio, è consigliabile chiamare sempre il metodo Close. Questa azione consente di liberare risorse di sistema limitate (ad esempio, socket e named pipe) vincolate alla durata del messaggio.

Nota speciale in caso di derivazione da questa classe in C++ gestito:

Inserire il codice di pulitura in (On)(Begin)Close (e/o OnAbort), non in un distruttore.
Evitare i distruttori: comportano la generazione automatica dell'interfaccia IDisposable da parte del compilatore.
Evitare membri di non riferimento: possono comportare la generazione automatica dell'interfaccia IDisposable da parte del compilatore.
Evitare i finalizzatori. Se, tuttavia, se ne include uno, eliminare l'avviso di compilazione e chiamare SuppressFinalize(Object) e il finalizzatore stesso mediante (On)(Begin)Close (e/o OnAbort) al fine di emulare ciò che sarebbe stato il comportamento di IDisposable generato automaticamente.

Note per gli eredi:

Quando si eredita dalla classe Message, è necessario eseguire l'override dei membri seguenti: Headers e Version.

Esempi

Nell'esempio di codice seguente viene illustrato un client che utilizza la channel factory per inviare un messaggio e leggere la risposta.

C++


using System;
using System.Messaging;

public class Order
{
    private int _orderId;
    private DateTime _orderTime;

    public int orderId
    {
        get
        {
            return _orderId;
        }
        set
        {
            _orderId = value;
        }
    }
    public DateTime orderTime
    {
        get
        {
            return _orderTime;
        }
        set
        {
            _orderTime = value;
        }
    }

    public Order()
    {
    }
};	

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

        try
        {
            // Create a non-transactional queue on the local computer.
            // Note that the queue might not be immediately accessible, and
            // therefore this example might throw an exception of type
            // System.Messaging.MessageQueueException when trying to send a
            // message to the newly created queue.
            CreateQueue(".\\orderQueue", false);

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

            // Receive a message from a queue.
            processor.ReceiveMessage();

            // Create a transactional queue on the local computer.
            CreateQueue(".\\orderTransQueue", true);

            // Send a message to a transactional queue.
            processor.SendMessageToTransQueue();

            // Receive a message from a transactional queue.
            processor.ReceiveMessageFromTransQueue();
        }
        catch(System.Exception e)
        {
            // Write the exception information to the console.
            Console.WriteLine(e);
        }
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Sends an Order to a queue.
    public void SendMessage()
    {
        // Create a new order and set values.
        Order sentOrder = new Order();
        sentOrder.orderId = 3;
        sentOrder.orderTime = DateTime.Now;

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

        // Create the new order.
        Message orderMessage = new Message(sentOrder);

        // Set the message's TimeToReachQueue property to five minutes.
        orderMessage.TimeToReachQueue = TimeSpan.FromMinutes(5.0);

        // Display the new value of the message's TimeToReachQueue property.
        Console.WriteLine("Message.TimeToReachQueue: {0}",
            orderMessage.TimeToReachQueue.ToString());

        // Set the message's TimeToBeReceived property to five minutes.
        orderMessage.TimeToBeReceived = TimeSpan.FromMinutes(5.0);

        // Display the new value of the message's TimeToBeReceived property.
        Console.WriteLine("Message.TimeToBeReceived: {0}",
            orderMessage.TimeToBeReceived.ToString());

        // Set the message's UseTracing property to true.
        orderMessage.UseTracing = true;

        // Display the new value of the message's UseTracing property.
        Console.WriteLine("Message.UseTracing: {0}", orderMessage.UseTracing);

        // Set the message's Label property.
        orderMessage.Label = "Order Message";

        // Display the new value of the message's Label property.
        Console.WriteLine("Message Label: {0}", orderMessage.Label);

        // Set the message's AttachSenderId property.
        orderMessage.AttachSenderId = true;

        // Display the new value of the message's AttachSenderId property.
        Console.WriteLine("Message.AttachSenderId: {0}",
            orderMessage.AttachSenderId);

        // Set the message's Recoverable property.
        orderMessage.Recoverable = true;

        // Display the new value of the message's Recoverable property.
        Console.WriteLine("Message.Recoverable: {0}",
            orderMessage.Recoverable);

        // Set the message's ResponseQueue property.
        // (You must have a connection to a queue.)
        orderMessage.ResponseQueue = queue;

        // Display the new value of the message's ResponseQueue property.
        Console.WriteLine("Message.ResponseQueue.QueueName: {0}",
            orderMessage.ResponseQueue.QueueName);

        // Set the message's TimeToReachQueue property to Message.InfiniteTimeout.
        orderMessage.TimeToReachQueue = Message.InfiniteTimeout;

        // Display the new value of the message's TimeToReachQueue property.
        Console.WriteLine("Message.TimeToReachQueue: {0}",
            orderMessage.TimeToReachQueue.ToString());

        // Set the message's UseDeadLetterQueue property.
        orderMessage.UseDeadLetterQueue = true;

        // Display the new value of the message's UseDeadLetterQueue property.
        Console.WriteLine("Message.UseDeadLetterQueue: {0}",
            orderMessage.UseDeadLetterQueue);

        // Set the message's UseJournalQueue property.
        orderMessage.UseJournalQueue = true;

        // Display the new value of the message's UseJournalQueue property.
        Console.WriteLine("Message.UseJournalQueue: {0}",
            orderMessage.UseJournalQueue);

        // Set the message's UseEncryption property.
        orderMessage.UseEncryption = true;

        // Display the new value of the message's UseEncryption property.
        Console.WriteLine("Message.UseEncryption: {0}",
            orderMessage.UseEncryption);

        // Send the order to the queue.
        queue.Send(orderMessage);
    }

    // Receives a message containing an order.
    public void ReceiveMessage()
    {
        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\orderQueue");

        // Set the formatter to indicate the message body contains an order.
        queue.Formatter = new XmlMessageFormatter(new Type[]
            {typeof(Order)});

        // Set the queue's MessageReadPropertyFilter properties to ensure that
        // the message includes the properties in which we are interested.
        queue.MessageReadPropertyFilter.ArrivedTime = true;
        queue.MessageReadPropertyFilter.DestinationQueue = true;
        queue.MessageReadPropertyFilter.SenderVersion = true;
        queue.MessageReadPropertyFilter.SentTime = true;
        queue.MessageReadPropertyFilter.SourceMachine = true;
        queue.MessageReadPropertyFilter.Authenticated = true;

        // Receive the message. Time out after ten seconds in case the message
        // was not delivered.
        Message orderMessage = queue.Receive(TimeSpan.FromSeconds(10.0));

        // Format the message.
        Order sentOrder = (Order)orderMessage.Body;

        // Display message information.
        Console.WriteLine("Order ID: {0}", sentOrder.orderId.ToString());
        Console.WriteLine("Sent: {0}", sentOrder.orderTime.ToString());

        // Display the value of the message's MessageType property.
        Console.WriteLine("Message Type: {0}", orderMessage.MessageType);

        // Display the value of the message's SourceMachine property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.SourceMachine property must be set to
        // true before the message is received.
        Console.WriteLine("Source Machine: {0}", orderMessage.SourceMachine);

        // Display the value of the message's DestinationQueue property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.DestinationQueue property must be set to
        // true before the message is received.
        Console.WriteLine("Message.DestinationQueue.QueueName: {0}",
            orderMessage.DestinationQueue.QueueName);

        // Display the value of the message's SentTime property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.SentTime property must be set to
        // true before the message is received.
        Console.WriteLine("Time sent from source queue: {0}",
            orderMessage.SentTime.ToString());

        // Display the value of the message's ArrivedTime property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.ArrivedTime property must be set to
        // true before the message is received.
        Console.WriteLine("Time arrived in destination queue: {0}",
            orderMessage.ArrivedTime.ToString());

        // Display the value of the message's Authenticated property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.Authenticated property must be set to
        // true before the message is received.
        Console.WriteLine("Authentication requested for this message: {0}",
            orderMessage.Authenticated.ToString());

        // Display the value of the message's SenderVersion property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.SenderVersion property must be set to
        // true before the message is received.
        Console.WriteLine("Message.SenderVersion: {0}",
            orderMessage.SenderVersion);

        // Message Queuing sets this property when the message is sent.
        // Display the value of the message's BodyType property.
        Console.WriteLine("Message.BodyType: {0}",
            orderMessage.BodyType.ToString());
    }

    // Sends an Order to a transactional queue.
    public void SendMessageToTransQueue()
    {
        // Create a new order and set values.
        Order sentOrder = new Order();
        sentOrder.orderId = 3;
        sentOrder.orderTime = DateTime.Now;

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

        // Create the new order.
        Message orderMessage = new Message(sentOrder);

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

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

            // Send the order to the queue.
            queue.Send(orderMessage, transaction);

            // Commit the transaction.
            transaction.Commit();
        }
        catch (MessageQueueException e)
        {
            // Abort the transaction.
            transaction.Abort();

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

    // Receives a message containing an order.
    public void ReceiveMessageFromTransQueue()
    {
        Message orderMessage;

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

        // Set the formatter to indicate the message body contains an order.
        queue.Formatter = new XmlMessageFormatter(new Type[]
            {typeof(Order)});

        // Set the queue's MessageReadPropertyFilter properties to ensure that
        // the message includes the properties in which we are interested.
        queue.MessageReadPropertyFilter.TransactionId = true;
        queue.MessageReadPropertyFilter.TransactionStatusQueue = true;
        queue.MessageReadPropertyFilter.IsFirstInTransaction = true;
        queue.MessageReadPropertyFilter.IsLastInTransaction = true;

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

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

            // Receive the message. Time out after ten seconds in case the
            // message was not delivered.
            orderMessage = queue.Receive(TimeSpan.FromSeconds(10.0),
                transaction);

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

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

        // Message Queuing sets this property when the message is sent.
        // Display the value of the message's TransactionStatusQueue property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.TransactionStatusQueue property must be
        // set to true before the message is received.
        Console.WriteLine("Message.TransactionStatusQueue.QueueName: {0}",
            orderMessage.TransactionStatusQueue.QueueName);

        // Display the value of the message's TransactionId property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.TransactionId property must be set to true
        // before the message is received.
        Console.WriteLine("Message.TransactionId: {0}",
            orderMessage.TransactionId);

        // Display the value of the message's IsFirstInTransaction property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.IsFirstInTransaction property must be set
        // to true before the message is received.
        Console.WriteLine("Message.IsFirstInTransaction: {0}",
            orderMessage.IsFirstInTransaction);

        // Display the value of the message's IsLastInTransaction property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.IsLastInTransaction property must be set
        // to true before the message is received.
        Console.WriteLine("Message.IsLastInTransaction: {0}",
            orderMessage.IsLastInTransaction);
    }
}

import System.*;
import System.Messaging.*;

public class Order
{
    private int _orderId;
    private DateTime _orderTime;

    /** @property 
     */
    public int get_orderId()
    {
        return _orderId;
    } //get_orderId

    /** @property 
     */
    public void set_orderId(int value)
    {
        _orderId = value;
    } //set_orderId

    /** @property 
     */
    public DateTime get_orderTime()
    {
        return _orderTime;
    } //get_orderTime

    /** @property 
     */
    public void set_orderTime(DateTime value)
    {
        _orderTime = value;
    } //set_orderTime

    public Order()
    {
    } //Order
} //Order

public class OrderProcessor
{
    public static void main(String[] args)
    {
        // Create a new instance of the class.
        OrderProcessor processor = new OrderProcessor();

        try {
            // Create a non-transactional queue on the local computer.
            // Note that the queue might not be immediately accessible, and
            // therefore this example might throw an exception of type
            // System.Messaging.MessageQueueException when trying to send a
            // message to the newly created queue.
            CreateQueue(".\\orderQueue", false);
            // Send a message to a queue.
            processor.SendMessage();
            // Receive a message from a queue.
            processor.ReceiveMessage();
            // Create a transactional queue on the local computer.
            CreateQueue(".\\orderTransQueue", true);
            // Send a message to a transactional queue.
            processor.SendMessageToTransQueue();
            // Receive a message from a transactional queue.
            processor.ReceiveMessageFromTransQueue();
        }
        catch (System.Exception e) {
            // Write the exception information to the console.
            Console.WriteLine(e);
        }
    } //main

    // Creates a new queue.
    public static void CreateQueue(String queuePath, boolean transactional)
    {
        if (!(MessageQueue.Exists(queuePath))) {
            MessageQueue.Create(queuePath, transactional);
        }
        else {
            Console.WriteLine((queuePath + " already exists."));
        }
    } //CreateQueue

    // Sends an Order to a queue.
    public void SendMessage()
    {
        // Create a new order and set values.
        Order sentOrder = new Order();
        sentOrder.set_orderId(3);
        sentOrder.set_orderTime(DateTime.get_Now());
        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\orderQueue");
        // Create the new order.
        Message orderMessage = new Message(sentOrder);
        // Set the message's TimeToReachQueue property to five minutes.
        orderMessage.set_TimeToReachQueue(TimeSpan.FromMinutes(5.0));
        // Display the new value of the message's TimeToReachQueue property.
        Console.WriteLine("Message.TimeToReachQueue: {0}", 
            orderMessage.get_TimeToReachQueue().ToString());
        // Set the message's TimeToBeReceived property to five minutes.
        orderMessage.set_TimeToBeReceived(TimeSpan.FromMinutes(5.0));
        // Display the new value of the message's TimeToBeReceived property.
        Console.WriteLine("Message.TimeToBeReceived: {0}", 
            orderMessage.get_TimeToBeReceived().ToString());
        // Set the message's UseTracing property to true.
        orderMessage.set_UseTracing(true);
        // Display the new value of the message's UseTracing property.
        Console.WriteLine("Message.UseTracing: {0}", 
            System.Convert.ToString(orderMessage.get_UseTracing()));
        // Set the message's Label property.
        orderMessage.set_Label("Order Message");
        // Display the new value of the message's Label property.
        Console.WriteLine("Message Label: {0}", orderMessage.get_Label());
        // Set the message's AttachSenderId property.
        orderMessage.set_AttachSenderId(true);
        // Display the new value of the message's AttachSenderId property.
        Console.WriteLine("Message.AttachSenderId: {0}", 
            System.Convert.ToString(orderMessage.get_AttachSenderId()));
        // Set the message's Recoverable property.
        orderMessage.set_Recoverable(true);
        // Display the new value of the message's Recoverable property.
        Console.WriteLine("Message.Recoverable: {0}", 
            System.Convert.ToString(orderMessage.get_Recoverable()));
        // Set the message's ResponseQueue property.
        // (You must have a connection to a queue.)
        orderMessage.set_ResponseQueue(queue);
        // Display the new value of the message's ResponseQueue property.
        Console.WriteLine("Message.ResponseQueue.QueueName: {0}", 
            orderMessage.get_ResponseQueue().get_QueueName().ToString());
        // Set the message's TimeToReachQueue property to Message.InfiniteTimeout.
        orderMessage.set_TimeToReachQueue(Message.InfiniteTimeout);
        // Display the new value of the message's TimeToReachQueue property.
        Console.WriteLine("Message.TimeToReachQueue: {0}", 
            System.Convert.ToString(orderMessage.get_TimeToReachQueue()));
        // Set the message's UseDeadLetterQueue property.
        orderMessage.set_UseDeadLetterQueue(true);
        // Display the new value of the message's UseDeadLetterQueue property.
        Console.WriteLine("Message.UseDeadLetterQueue: {0}", 
            System.Convert.ToString(orderMessage.get_UseDeadLetterQueue()));
        // Set the message's UseJournalQueue property.
        orderMessage.set_UseJournalQueue(true);
        // Display the new value of the message's UseJournalQueue property.
        Console.WriteLine("Message.UseJournalQueue: {0}", 
            System.Convert.ToString(orderMessage.get_UseJournalQueue()));
        // Set the message's UseEncryption property.
        orderMessage.set_UseEncryption(true);
        // Display the new value of the message's UseEncryption property.
        Console.WriteLine("Message.UseEncryption: {0}", 
            System.Convert.ToString(orderMessage.get_UseEncryption()));
        // Send the order to the queue.
        queue.Send(orderMessage);
    } //SendMessage

    // Receives a message containing an order.
    public void ReceiveMessage()
    {
        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\orderQueue");
        // Set the formatter to indicate the message body contains an order.
        queue.set_Formatter(new XmlMessageFormatter(new Type[] { 
            Order.class.ToType() }));
        // Set the queue's MessageReadPropertyFilter properties to ensure that
        // the message includes the properties in which we are interested.
        queue.get_MessageReadPropertyFilter().set_ArrivedTime(true);
        queue.get_MessageReadPropertyFilter().set_DestinationQueue(true);
        queue.get_MessageReadPropertyFilter().set_SenderVersion(true);
        queue.get_MessageReadPropertyFilter().set_SentTime(true);
        queue.get_MessageReadPropertyFilter().set_SourceMachine(true);
        queue.get_MessageReadPropertyFilter().set_Authenticated(true);
        // Receive the message. Time out after ten seconds in case the message
        // was not delivered.
        Message orderMessage = queue.Receive(TimeSpan.FromSeconds(10.0));
        // Format the message.
        Order sentOrder = ( Order)orderMessage.get_Body();
        // Display message information.
        Console.WriteLine("Order ID: {0}", 
            System.Convert.ToString(sentOrder.get_orderId()));
        Console.WriteLine("Sent: {0}", 
            System.Convert.ToString(sentOrder.get_orderTime()));
        // Display the value of the message's MessageType property.
        Console.WriteLine("Message Type: {0}", 
            System.Convert.ToString(orderMessage.get_MessageType()));
        // Display the value of the message's SourceMachine property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.SourceMachine property must be set to
        // true before the message is received.
        Console.WriteLine("Source Machine: {0}", 
            System.Convert.ToString(orderMessage.get_SourceMachine()));
        // Display the value of the message's DestinationQueue property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.DestinationQueue property must be set to
        // true before the message is received.
        Console.WriteLine("Message.DestinationQueue.QueueName: {0}", 
            System.Convert.ToString(orderMessage.get_DestinationQueue().
            get_QueueName()));
        // Display the value of the message's SentTime property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.SentTime property must be set to
        // true before the message is received.
        Console.WriteLine("Time sent from source queue: {0}", 
            System.Convert.ToString(orderMessage.get_SentTime()));
        // Display the value of the message's ArrivedTime property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.ArrivedTime property must be set to
        // true before the message is received.
        Console.WriteLine("Time arrived in destination queue: {0}", 
            System.Convert.ToString(orderMessage.get_ArrivedTime()));
        // Display the value of the message's Authenticated property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.Authenticated property must be set to
        // true before the message is received.
        Console.WriteLine("Authentication requested for this message: {0}", 
            System.Convert.ToString(orderMessage.get_Authenticated()));
        // Display the value of the message's SenderVersion property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.SenderVersion property must be set to
        // true before the message is received.
        Console.WriteLine("Message.SenderVersion: {0}", 
            System.Convert.ToString(orderMessage.get_SenderVersion()));
        // Message Queuing sets this property when the message is sent.
        // Display the value of the message's BodyType property.
        Console.WriteLine("Message.BodyType: {0}", 
            System.Convert.ToString(orderMessage.get_BodyType()));
    } //ReceiveMessage

    // Sends an Order to a transactional queue.
    public void SendMessageToTransQueue() throws MessageQueueException
    {
        // Create a new order and set values.
        Order sentOrder = new Order();
        sentOrder.set_orderId(3);
        sentOrder.set_orderTime(DateTime.get_Now());
        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\orderTransQueue");
        // Create the new order.
        Message orderMessage = new Message(sentOrder);
        // Create a message queuing transaction.
        MessageQueueTransaction transaction = new MessageQueueTransaction();

        try {
            // Begin a transaction.
            transaction.Begin();
            // Send the order to the queue.
            queue.Send(orderMessage, transaction);
            // Commit the transaction.
            transaction.Commit();
        }
        catch (MessageQueueException e) {
            // Abort the transaction.
            transaction.Abort();
            // Propagate the exception.
            throw e;
        }
        finally {
            // Dispose of the transaction object.
            transaction.Dispose();
        }
    } //SendMessageToTransQueue

    // Receives a message containing an order.
    public void ReceiveMessageFromTransQueue() throws System.Exception
    {
        Message orderMessage;
        // Connect to the a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\orderTransQueue");
        // Set the formatter to indicate the message body contains an order.
        queue.set_Formatter(new XmlMessageFormatter(new Type[] { 
            Order.class.ToType() }));
        // Set the queue's MessageReadPropertyFilter properties to ensure that
        // the message includes the properties in which we are interested.
        queue.get_MessageReadPropertyFilter().set_TransactionId(true);
        queue.get_MessageReadPropertyFilter().set_TransactionStatusQueue(true);
        queue.get_MessageReadPropertyFilter().set_IsFirstInTransaction(true);
        queue.get_MessageReadPropertyFilter().set_IsLastInTransaction(true);
        // Create a message queuing transaction.
        MessageQueueTransaction transaction = new MessageQueueTransaction();

        try {
            // Begin a transaction.
            transaction.Begin();
            // Receive the message. Time out after ten seconds in case the
            // message was not delivered.
            orderMessage = queue.Receive(TimeSpan.FromSeconds(10.0), 
                transaction);
            // Commit the transaction.
            transaction.Commit();
        }
        catch (System.Exception e) {
            // Abort the transaction.
            transaction.Abort();
            // Propagate the exception.
            throw e;
        }
        finally {
            // Dispose of the transaction object.
            transaction.Dispose();
        }
        // Message Queuing sets this property when the message is sent.
        // Display the value of the message's TransactionStatusQueue property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.TransactionStatusQueue property must be
        // set to true before the message is received.
        Console.WriteLine("Message.TransactionStatusQueue.QueueName: {0}", 
            orderMessage.get_TransactionStatusQueue().get_QueueName());
        // Display the value of the message's TransactionId property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.TransactionId property must be set to true
        // before the message is received.
        Console.WriteLine("Message.TransactionId: {0}", 
            System.Convert.ToString(orderMessage.get_TransactionId()));
        // Display the value of the message's IsFirstInTransaction property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.IsFirstInTransaction property must be set
        // to true before the message is received.
        Console.WriteLine("Message.IsFirstInTransaction: {0}", 
            System.Convert.ToString(orderMessage.get_IsFirstInTransaction()));
        // Display the value of the message's IsLastInTransaction property.
        // To view this property value, the queue's
        // MessageReadPropertyFilter.IsLastInTransaction property must be set
        // to true before the message is received.
        Console.WriteLine("Message.IsLastInTransaction: {0}", 
            System.Convert.ToString(orderMessage.get_IsLastInTransaction()));
    } //ReceiveMessageFromTransQueue
} //OrderProcessor

using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Runtime.Serialization;

namespace ConsoleApplication1
{
    class client
    {


        static void RunClient()
        {
            //Step1: create a binding with just HTTP
            CustomBinding binding = new CustomBinding();
            binding.Elements.Add(new HttpTransportBindingElement());
            //Step2: use the binding to build the channel factory
            IChannelFactory<IRequestChannel> factory =
            binding.BuildChannelFactory<IRequestChannel>(
                             new BindingParameterCollection());
            //open the channel factory
            factory.Open();
            //Step3: use the channel factory to create a channel
            IRequestChannel channel = factory.CreateChannel(
               new EndpointAddress("http://localhost:8080/channelapp"));
            channel.Open();
            //Step4: create a message
            Message requestmessage = Message.CreateMessage(
                MessageVersion.Soap12WSAddressing10,
                "http://contoso.com/someaction",
                 "This is the body data");
            //send message
            Message replymessage = channel.Request(requestmessage);
            Console.WriteLine("Reply message received");
            Console.WriteLine("Reply action: {0}",
                                  replymessage.Headers.Action);
            string data = replymessage.GetBody<string>();
            Console.WriteLine("Reply content: {0}", data);
            //Step5: don't forget to close the message
            requestmessage.Close();
            replymessage.Close();
            //don't forget to close the channel
            channel.Close();
            //don't forget to close the factory
            factory.Close();
        }
        public static void Main()
        {
            Console.WriteLine("Press [ENTER] when service is ready");
            Console.ReadLine();
            RunClient();
            Console.WriteLine("Press [ENTER] to exit");
            Console.ReadLine();
        }
    }
}

Gerarchia di ereditarietà

System.Object
System.ServiceModel.Channels.Message

Codice thread safe

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Piattaforme

Windows Vista, Windows XP SP2, Windows Server 2003, Windows CE, Windows Mobile per Smartphone, Windows Mobile per Pocket PC

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Informazioni sulla versione

.NET Framework

Supportato in: 3.5, 3.0

.NET Compact Framework

Supportato in: 3.5

Vedere anche

Riferimenti

Membri Message

Spazio dei nomi System.ServiceModel.Channels

Il documento è risultato utile? Sì No

Non accurato

Incompleto

Ulteriori esempi di codice

La traduzione deve essere migliorata

(1500 caratteri rimanenti)

Aggiunte alla community

AGGIUNGI