MessagePropertyFilter Class

Controls and selects the properties that are retrieved when peeking or receiving messages from a message queue.

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

[TypeConverterAttribute(typeof(ExpandableObjectConverter))]
public class MessagePropertyFilter : ICloneable

Setting the MessagePropertyFilter on a MessageQueue instance controls the set of properties that are retrieved when peeking or receiving a message. The filter is set on the instance of MessageQueue that retrieves the message information. When you set a MessagePropertyFilter Boolean-valued member to false, you prevent the information of the associated Message property from being retrieved by the MessageQueue.

There are several filter properties that are not Boolean values. They are integer values that get or set the default sizes of the Message.Body, Message.Extension, or Message.Label.

Retrieving a limited set of properties helps improve performance because smaller amounts of data are transferred from the queue.

When setting a property on MessagePropertyFilter, you are only indicating whether that property is retrieved when a message is received or peeked. You are not changing the associated property value for the Message.

The MessagePropertyFilter constructor sets all filter properties to their default values, which for the Boolean values is false. See the constructor topic for the defaults assigned to the integer-valued properties.

The following code example sends two messages of different priorities to the queue, and retrieves them subsequently.

using System;
using System.Messaging;

namespace MyProject
{

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

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

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

			// Send messages to a queue.
			myNewQueue.SendMessage(MessagePriority.Normal, "First Message Body.");
			myNewQueue.SendMessage(MessagePriority.Highest, "Second Message Body.");

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

			return;
		}


		//************************************************** 
		// Sends a string message to a queue. 
		//************************************************** 
		
		public void SendMessage(MessagePriority priority, string messageBody)
		{

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

			// Create a new message.
			Message myMessage = new Message();

			if(priority > MessagePriority.Normal)
			{
				myMessage.Body = "High Priority: " + messageBody;
			}
			else myMessage.Body = messageBody;

			// Set the priority of the message.
			myMessage.Priority = priority;


			// Send the Order to the queue.
			myQueue.Send(myMessage);

			return;
		}


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

			// Set the queue to read the priority. By default, it 
			// is not read.
			myQueue.MessageReadPropertyFilter.Priority = true;

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

				// Display message information.
				Console.WriteLine("Priority: " + 
					myMessage.Priority.ToString());
				Console.WriteLine("Body: " + 
					myMessage.Body.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 namespace System;
using namespace System::Messaging;

__gc class MyNewQueue 
{
public:
	void SendMessage(MessagePriority priority, String* messageBody) 
	{

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

		// Create a new message.
		Message* myMessage = new Message();

		if (priority > MessagePriority::Normal) 
		{
			myMessage->Body = S"High Priority: {0}", messageBody;
		} 
		else myMessage->Body = messageBody;

		// Set the priority of the message.
		myMessage->Priority = priority;

		// Send the Order to the queue.
		myQueue->Send(myMessage);

		return;
	}

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

		// Set the queue to read the priority. By default, it
		// is not read.
		myQueue->MessageReadPropertyFilter->Priority = true;

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

		try 
		{
			// Receive and format the message. 
			Message* myMessage = myQueue->Receive(); 

			// Display message information.
			Console::WriteLine(S"Priority: {0}", __box(myMessage->Priority));
			Console::WriteLine(S"Body: {0}", myMessage->Body);
		}
		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();

	// Send messages to a queue.
	myNewQueue->SendMessage(MessagePriority::Normal, S"First Message Body.");
	myNewQueue->SendMessage(MessagePriority::Highest, S"Second Message Body.");

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

	return 0;

System.Object
  System.Messaging.MessagePropertyFilter

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
Was this page helpful?
(1500 characters remaining)
Thank you for your feedback

Community Additions

ADD
Show:
© 2014 Microsoft