Export (0) Print
Expand All

MessageHeaders Class

Represents a collection of message headers for a message. This class cannot be inherited.

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

public sealed class MessageHeaders : IEnumerable<MessageHeaderInfo>, IEnumerable
public final class MessageHeaders implements IEnumerable<MessageHeaderInfo>, 
	IEnumerable
public final class MessageHeaders implements IEnumerable<MessageHeaderInfo>, 
	IEnumerable
Not applicable.

A message header contains optional metadata that describe a message encapsulated by the Message class.

A Message can have zero or more headers that are used as an extension mechanism to pass information in messages that are application-specific. You can use Headers to add message headers to a message by calling the Add method.

Windows Communication Foundation (WCF) provides a number of predefined message headers:

Header Name

Description

To

Contains the role that the message is targeting.

Action

Provides a description of how the message should be processed.

FaultTo

Contains the address of the node to which faults should be sent.

From

Contains the address of the node that sent the message.

Request

Indicates whether the message is a request.

MessageID

Contains the unique ID of the message.

RelatesTo

Contains the IDs of messages that are related to this message.

ReplyTo

Contains the address of the node to which a reply should be sent for a request.

The following code example demonstrates a simple client using the channel factory to send a message and read the action header from the reply.


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 

System.Object
  System.ServiceModel.Channels.MessageHeaders

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0

Community Additions

ADD
Show:
© 2014 Microsoft