Export (0) Print
Expand All

Message Class

Provides access to the properties needed to define a Message Queuing message.

Namespace:  System.Messaging
Assembly:  System.Messaging (in System.Messaging.dll)

public class Message : Component

Use the Message class to peek or receive messages from a queue, or to have fine control over message properties when sending a message to a queue.

MessageQueue uses the Message class when it peeks or receives messages from queues, because both the MessageQueue.Peek and MessageQueue.Receive methods create a new instance of the Message class and set the instance's properties. The Message class's read-only properties apply to retrieving messages from a queue, while the read/write properties apply to sending and retrieving messages. When MessageQueue peeks or receives a message from a queue, its MessageReadPropertyFilter property determines which of the message's properties are retrieved.

The MessageQueue class's Send method allows you to specify any object type for a message being sent to that queue. You can use the MessageQueue instance's DefaultPropertiesToSend property to specify settings for generic messages sent to the queue. The types of settings include formatter, label, encryption, and authentication. You can also specify values for the appropriate DefaultPropertiesToSend members when you coordinate your messaging application to respond to acknowledgment and report messages. Using a Message instance to send a message to the queue gives you the flexibility to access and modify many of these properties—either for a single message or on a message-by-message basis. Message properties take precedence over DefaultPropertiesToSend.

Message data is stored in the Body property and to a lesser extent, the AppSpecific and Extension properties. When message data is encrypted, serialized, or deserialized, only the contents of the Body property are affected.

The contents of the Body property are serialized when the message is sent, using the Formatter property you specify. The serialized contents are found in the BodyStream property. You can also set the BodyStream property directly, for example, to send a file as the data content of a message. You can change the Body or Formatter properties at any time before sending the message, and the data will be serialized appropriately when you call Send.

The properties defined by the MessageQueue.DefaultPropertiesToSend property apply only to messages that are not of type Message. If you specify the DefaultPropertiesToSend property for a MessageQueue, the identically named properties in a Message instance sent to that queue cause these default properties to be ignored.

For a list of initial property values for an instance of Message, see the Message constructor.

The following code example demonstrates formatting a message body using BinaryMessageFormatter.

using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{
	

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

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

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

			// Create a queue on the local computer.
			CreateQueue(".\\myQueue");
			
			// Send a message to a queue.
			myNewQueue.SendMessage();

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

			return;
		}

		//************************************************** 
		// Creates a new queue. 
		//************************************************** 

		public static void CreateQueue(string queuePath)
		{
			try	
				{
				if(!MessageQueue.Exists(queuePath))
				{
					MessageQueue.Create(queuePath);
				}
				else
				{
					Console.WriteLine(queuePath + " already exists.");
				}
			}
			catch (MessageQueueException e)
			{
				Console.WriteLine(e.Message);
			}
			
		}

		//************************************************** 
		// Sends an image to a queue, using the BinaryMessageFormatter. 
		//************************************************** 
		
		public void SendMessage()
		{
			try{

				// Create a new bitmap. 
				// The file must be in the \bin\debug or \bin\retail folder, or 
				// you must give a full path to its location.
				Image myImage = Bitmap.FromFile("SentImage.bmp");

				// Connect to a queue on the local computer.
				MessageQueue myQueue = new MessageQueue(".\\myQueue");
				
				Message myMessage = new Message(myImage, new BinaryMessageFormatter());

				// Send the image to the queue.
				myQueue.Send(myMessage);
			}
			catch(ArgumentException e)
			{
				Console.WriteLine(e.Message);
			
			}

			return;
		}


		//************************************************** 
		// Receives a message containing an image. 
		//************************************************** 
		
		public   void ReceiveMessage()
		{
						
			try
			{

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

				// Set the formatter to indicate body contains an Order.
				myQueue.Formatter = new BinaryMessageFormatter();

				// Receive and format the message. 
				System.Messaging.Message myMessage = myQueue.Receive(); 
				Bitmap myImage = (Bitmap)myMessage.Body;
				
				// This will be saved in the \bin\debug or \bin\retail folder.
				myImage.Save("ReceivedImage.bmp",System.Drawing.Imaging.ImageFormat.Bmp);
				
				
			}
			
			catch (MessageQueueException)
			{
				// Handle Message Queuing exceptions.
			}

			// Handle invalid serialization format. 
			catch (InvalidOperationException e)
			{
				Console.WriteLine(e.Message);
			}

			catch (IOException e)
			{
				// Handle file access exceptions.
			}
			
			// Catch other exceptions as necessary. 

			return;
		}
	}
}
#using <mscorlib.dll>
#using <system.dll>
#using <system.messaging.dll>
#using <system.drawing.dll>

using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;

/// <summary>
/// Provides a container class for the example.
/// </summary>
__gc class MyNewQueue 
{
	//*************************************************
	// Creates a new queue.
	//*************************************************
public:
	static void CreateQueue(String* queuePath) 
	{
		try 
		{
			if (!MessageQueue::Exists(queuePath)) 
			{
				MessageQueue::Create(queuePath);
			}
			else 
			{
				Console::WriteLine("{0} already exists.", queuePath);
			}
		} 
		catch (MessageQueueException* e) 
		{
			Console::WriteLine(e->Message);
		}

	}

	//*************************************************
	// Sends an image to a queue, using the BinaryMessageFormatter.
	//*************************************************
public:
	void SendMessage() 
	{
		try 
		{
			// Create a new bitmap.
			// The file must be in the \bin\debug or \bin\retail folder, or
			// you must give a full path to its location.
			Image* myImage = Bitmap::FromFile(S"SentImage::bmp");

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

			Message* myMessage = new Message(myImage, new BinaryMessageFormatter());

			// Send the image to the queue.
			myQueue->Send(myMessage);
		} 
		catch (ArgumentException* e) 
		{
			Console::WriteLine(e->Message);
		}

		return;
	}

	//*************************************************
	// Receives a message containing an image.
	//*************************************************
public:
	void ReceiveMessage() 
	{
		try 
		{
			// Connect to the a queue on the local computer.
			MessageQueue* myQueue = new MessageQueue(S".\\myQueue");

			// Set the formatter to indicate body contains an Order.
			myQueue->Formatter = new BinaryMessageFormatter();

			// Receive and format the message. 
			Message* myMessage = myQueue->Receive(); 
			Bitmap* myImage = static_cast<Bitmap*>(myMessage->Body);

			// This will be saved in the \bin\debug or \bin\retail folder.
			myImage->Save(S"ReceivedImage::bmp", System::Drawing::Imaging::ImageFormat::Bmp);
		} 
		catch (MessageQueueException*) 
		{
			// Handle Message Queuing exceptions.
		}

		// Handle invalid serialization format.
		catch (InvalidOperationException* e) 
		{
			Console::WriteLine(e->Message);
		}
		catch (IOException* e) 
		{
			// Handle file access exceptions.
		}

		// Catch other exceptions as necessary.
		return;
	}
};

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

	// Create a queue on the local computer.
	MyNewQueue::CreateQueue(S".\\myQueue");

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

	// Receive a message from a queue.
	myNewQueue->ReceiveMessage();

	return 0;
}

The following code example demonstrates formatting a message body using XmlMessageFormatter.

using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{

	// The following example  
	// sends to a queue and receives from a queue. 
	public class Order
	{
		public int orderId;
		public DateTime orderTime;
	};	

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

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

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

			// Create a queue on the local computer.
			CreateQueue(".\\myQueue");
			
			// Send a message to a queue.
			myNewQueue.SendMessage();

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

			return;
		}

		//************************************************** 
		// Creates a new queue. 
		//************************************************** 

		public static void CreateQueue(string queuePath)
		{
			try	
			{
				if(!MessageQueue.Exists(queuePath))
				{
					MessageQueue.Create(queuePath);
				}
				else
				{
					Console.WriteLine(queuePath + " already exists.");
				}
			}
			catch (MessageQueueException e)
			{
				Console.WriteLine(e.Message);
			}
			
		}

		//************************************************** 
		// Sends an Order to a queue. 
		//************************************************** 
		
		public void SendMessage()
		{
			try
			{

				// 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 myQueue = new MessageQueue(".\\myQueue");


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

				// Send the order to the queue.
				myQueue.Send(myMessage);
			}
			catch(ArgumentException e)
			{
				Console.WriteLine(e.Message);
			
			}

			return;
		}


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

			// Set the formatter to indicate body contains an Order.
			myQueue.Formatter = new XmlMessageFormatter(new Type[]
				{typeof(MyProject.Order)});
			
			try
			{
				// Receive and format the message. 
				Message myMessage =	myQueue.Receive(); 
				Order myOrder = (Order)myMessage.Body;

				// Display message information.
				Console.WriteLine("Order ID: " + 
					myOrder.orderId.ToString());
				Console.WriteLine("Sent: " + 
					myOrder.orderTime.ToString());
			}
			
			catch (MessageQueueException)
			{
				// Handle Message Queuing exceptions.
			}

				// Handle invalid serialization format. 
			catch (InvalidOperationException e)
			{
				Console.WriteLine(e.Message);
			}
			
			// Catch other exceptions as necessary. 

			return;
		}
	}
}
#using <mscorlib.dll>
#using <system.dll>
#using <system.messaging.dll>
#using <system.drawing.dll>

using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;


__gc class Order 
{
public:
    int orderId;
    DateTime orderTime;
};    

__gc class MyNewQueue 
{
public:
    static void CreateQueue(String* queuePath) 
    {
        try 
        {
            if (!MessageQueue::Exists(queuePath)) 
            {
                MessageQueue::Create(queuePath);
            }
            else 
            {
                Console::WriteLine("{0} already exists.", queuePath );
            }
        } 
        catch (MessageQueueException* e) 
        {
            Console::WriteLine(e->Message);
        }
    }

    void SendMessage() 
    {
        try 
        {
            // 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* myQueue = new MessageQueue(S".\\myQueue");

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

            // Send the order to the queue.
            myQueue->Send(myMessage);
        } 
        catch (ArgumentException* e) 
        {
            Console::WriteLine(e->Message);

        }
        return;
    }

    void ReceiveMessage() 
    {
        // Connect to the a queue on the local computer.
        MessageQueue* myQueue = new MessageQueue(S".\\myQueue");

        // Set the formatter to indicate body contains an Order.
        Type* p __gc[] = new Type*[1];
        p[0] = __typeof(Order);
        myQueue->Formatter = new XmlMessageFormatter( p );

        try 
        {
            // Receive and format the message. 
            Message* myMessage = myQueue->Receive(); 
            Order* myOrder = dynamic_cast<Order*>(myMessage->Body);

            // Display message information.
            Console::WriteLine(S"Order ID: {0}", __box(myOrder->orderId));
            Console::WriteLine(S"Sent: {0}", __box(myOrder->orderTime));
        }
        catch (MessageQueueException*) 
        {
            // Handle Message Queuing exceptions.
        }
        // Handle invalid serialization format.
        catch (InvalidOperationException* e) 
        {
            Console::WriteLine(e->Message);
        }
        // Catch other exceptions as necessary.

        return;
    }
};

int main() 
{
    // Create a new instance of the class.
    MyNewQueue* myNewQueue = new MyNewQueue();

    // Create a queue on the local computer.
    MyNewQueue::CreateQueue(S".\\myQueue");

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

    // Receive a message from a queue.
    myNewQueue->ReceiveMessage();

    return 0;
}

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 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 3.5, 2.0

Community Additions

ADD
Show:
© 2014 Microsoft