Export (0) Print
Expand All
Expand Minimize

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)

public enum class MessagePriority

Member nameDescription
AboveNormalBetween High and Normal message priority.
HighHigh message priority.
HighestHighest message priority.
LowLow message priority.
LowestLowest message priority.
NormalNormal message priority.
VeryHighBetween Highest and High message priority.
VeryLowBetween Low and Lowest 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.


#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

/// <summary> 
/// Provides a container class for the example. 
/// </summary> 
ref class MyNewQueue
{
   //************************************************** 
   // Sends a string message to a queue. 
   //************************************************** 
public:
   void SendMessage( MessagePriority priority, String^ messageBody )
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Create a new message.
      Message^ myMessage = gcnew Message;
      if ( priority > MessagePriority::Normal )
      {
         myMessage->Body = "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;
   }

   //************************************************** 
   // Receives a message. 
   //************************************************** 
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew 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^. 
      array<Type^>^ p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();

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

//************************************************** 
// 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 = gcnew 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 0;
}

.NET Framework

Supported in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

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

Show:
© 2014 Microsoft