Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

Message-Klasse

Aktualisiert: November 2007

Stellt die Kommunikationseinheit zwischen Endpunkten in einer verteilten Umgebung dar.

Namespace:  System.ServiceModel.Channels
Assembly:  System.ServiceModel (in System.ServiceModel.dll)

public abstract class Message : IDisposable
public abstract class Message implements IDisposable
public abstract class Message implements IDisposable

Die Message-Klasse bietet eine Möglichkeit, beliebige Informationen zwischen einem Absender und Empfänger in einem Netzwerk zu kommunizieren. Sie kann zum Weiterleiten von Informationen, zum Vorschlagen oder Fordern einer Vorgehensweise oder zum Anfordern von Daten verwendet werden.

Die Struktur eines Message-Objekts stellt einen SOAP-Umschlag dar. Er besteht aus zwei verschiedenen Teilen: dem Nachrichtentext und einer optionalen Auflistung von Headern, die von der Headers-Klasse dargestellt werden. Der Nachrichteninhalt stellt von einer Anwendung definierte Daten dar, die von einem Absender an einen Empfänger gesendet werden. Die Nachrichtenheader ermöglichen die Erweiterung von System und Anwendungen, um sich ändernden Anforderungen gerecht zu werden, da Sie Code definieren können, mit dem nur bestimmte Header bearbeitet oder nur auf bestimmte Header reagiert wird. Sie können außerdem eigene Header definieren. Nachrichtenheader werden zusammen mit dem Inhalt der Nachricht serialisiert oder deserialisiert.

Nachrichten werden in bestimmten Formaten empfangen und gesendet. Es werden zwei Formate unterstützt: Das standardmäßige, textbasierte XML-Format und ein binäres XML-Format. Das Message-Objekt kann sowohl zum Darstellen von SOAP 1.1- als auch SOAP 1.2-Umschlägen verwendet werden. Beachten Sie, dass eine Instanz von Message bei der Erstellung festgelegt wird und an eine bestimmte SOAP-Version gebunden ist. Die Version-Eigenschaft stellt die SOAP-Version der Nachricht dar.

Ein Message-Objekt kann in einen externen Speicher serialisiert werden, indem die WriteMessage-Methode verwendet wird. Es können auch Eigenschaften der Nachricht serialisiert werden, wobei diese jedoch einzeln identifiziert und serialisiert werden müssen. Um eine Nachricht zu deserialisieren und ein Message-Objekt im Arbeitsspeicher zu erstellen, kann CreateMessage verwendet werden. Eigenschaften für die spezifische Message-Instanz müssen ebenfalls einzeln deserialisiert und manuell zur Eigenschaftenauflistung hinzugefügt werden .

Die Größe eines Message-Objekts ist an die Größe der Daten, die es überträgt, gebunden. Jeder Nachrichtentext ist als Instanz von XmlReader angelegt, wobei der Stream, der von der XmlReader-Instanz eingebunden wird, keiner vordefinierten Größenbeschränkung unterliegt. Bestimmte Channelanbieter können jedoch die Größe der Nachrichten, die sie verarbeiten, beschränken.

Eine Message kann mit nützlichen Informationen kommentiert werden, die von einer Entität generiert werden, die die Nachricht überprüft und verarbeitet hat. Diese Funktionen werden von der Headers-Eigenschaft und Properties-Eigenschaft zur Verfügung gestellt. Die Headers-Auflistung stellt den Satz von SOAP-Headern in der Nachricht dar.

Die Properties-Eigenschaft stellt den Satz von Anmerkungen auf Verarbeitungsebene über die Nachricht dar. Da Informationen in Headern über das Netzwerk gesendet werden, muss eine Entität, die einen Header überprüft, die zugrunde liegende(n) Version(en) der vom Header verwendeten Protokolle unterstützen. Eigenschaften bieten jedoch eine weniger versionsabhängige Möglichkeit zum Kommentieren einer Nachricht.

Verwenden Sie zum Erstellen einer Message-Instanz eine der CreateMessage-Methoden.

Es wird empfohlen, dass ein Consumer einer Nachricht immer Close aufruft, wenn der Consumer nicht mehr auf den Nachrichteninhalt zugreift. Hierdurch werden finite Systemressourcen (beispielsweise Sockets und Named Pipes) freigegeben, die mit der Lebensdauer der Nachricht verknüpft sind.

Spezieller Hinweis für Benutzer von Managed C++, die von dieser Klasse ableiten:

  • Fügen Sie den Bereinigungscode in (On)(Begin)Close (and/or OnAbort) ein, nicht in einen Destruktor.

  • Vermeiden Sie Destruktoren: Sie bewirken, dass der Compiler IDisposable automatisch generiert.

  • Vermeiden Sie Member ohne Verweis: Sie können bewirken, dass der Compiler IDisposable automatisch generiert.

  • Vermeiden Sie Finalizer. Wenn Sie dennoch einen Finalizer verwenden, sollten Sie die Buildwarnung unterdrücken und SuppressFinalize(Object) sowie den Finalizer selbst über (On)(Begin)Close (and/or OnAbort) aufrufen, um das ansonsten automatisch generierte IDisposable-Verhalten zu emulieren.

Hinweise zur Vererbung:

Wenn Sie von Message erben, müssen Sie folgende Member überschreiben: Headers und Version.

Das folgende Codebeispiel zeigt einen Client, der die Kanalfactory zum Senden einer Nachricht und zum Lesen der Antwort verwendet.


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


System.Object
  System.ServiceModel.Channels.Message

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Windows Vista, Windows XP SP2, Windows Server 2003, Windows CE, Windows Mobile für Smartphone, Windows Mobile für Pocket PC

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0

.NET Compact Framework

Unterstützt in: 3.5
Anzeigen: