This documentation is archived and is not being maintained.

MessagePriority Enumeration

Specifies the priority Message Queuing applies to a message while it is en route to a queue, and when inserting the message into the destination queue.

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

'Declaration
Public Enumeration MessagePriority
'Usage
Dim instance As MessagePriority

Member nameDescription
Supported by the .NET Compact FrameworkLowestLowest message priority.
Supported by the .NET Compact FrameworkVeryLowBetween Low and Lowest message priority.
Supported by the .NET Compact FrameworkLowLow message priority.
Supported by the .NET Compact FrameworkNormalNormal message priority.
Supported by the .NET Compact FrameworkAboveNormalBetween High and Normal message priority.
Supported by the .NET Compact FrameworkHighHigh message priority.
Supported by the .NET Compact FrameworkVeryHighBetween Highest and High message priority.
Supported by the .NET Compact FrameworkHighestHighest message priority.

The MessagePriority enumeration is used by the Message class's Priority property. This property affects how Message Queuing handles the message both while it is en route and once it reaches its destination. Higher-priority messages are given preference during routing and inserted toward the front of the destination queue. Messages with the same priority are placed in the queue according to their arrival time.

When Message Queuing routes a message to a public queue, the priority level of the message is added to the priority level of the public queue (which you can access through the MessageQueue class's BasePriority property). The priority level of the queue has no effect on how messages are placed in the queue, only on how Message Queuing handles the message while en route.

Base priority applies only to public queues. For a private queue, the base priority is always zero.

You can set a meaningful priority only for non-transactional messages. Message Queuing automatically sets the priority for transactional messages to Lowest, which causes transactional message priority to be ignored.

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

Imports System
Imports System.Messaging


'Provides a container class for the example. 
Public Class MyNewQueue



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

      Public Shared Sub Main()
         ' Create a new instance of the class. 
         Dim myNewQueue As 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 
      End Sub 'Main




      ' Sends a string message to a queue. 

      Public Sub SendMessage(priority As MessagePriority, messageBody As String)

         ' Connect to a queue on the local computer. 
         Dim myQueue As New MessageQueue(".\myQueue")

         ' Create a new message. 
         Dim myMessage As New Message()

         If priority > MessagePriority.Normal Then
            myMessage.Body = "High Priority: " + messageBody
         Else
            myMessage.Body = messageBody
         End If  
         ' Set the priority of the message.
         myMessage.Priority = priority


         ' Send the Order to the queue.
         myQueue.Send(myMessage)

         Return 
      End Sub 'SendMessage




      ' Receives a message. 

      Public Sub ReceiveMessage()
         ' Connect to the a queue on the local computer. 
         Dim myQueue As 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() {GetType(String)})

         Try 
            ' Receive and format the message.  
            Dim myMessage As Message = myQueue.Receive()

            ' Display message information.
            Console.WriteLine(("Priority: " + myMessage.Priority.ToString()))
            Console.WriteLine(("Body: " + myMessage.Body.ToString()))



         ' Handle invalid serialization format. 
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try 

         ' Catch other exceptions as necessary. 
         Return 
      End Sub 'ReceiveMessage
   End Class 'MyNewQueue
#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;

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
Show: