MessagePriority MessagePriority MessagePriority MessagePriority Enum

Definizione

Specifica la priorità che Accodamento messaggi applica a un messaggio durante l'instradamento a una coda e durante il suo inserimento nella coda di destinazione.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.

public enum class MessagePriority
[System.Serializable]
public enum MessagePriority
type MessagePriority = 
Public Enum MessagePriority
Ereditarietà
MessagePriorityMessagePriorityMessagePriorityMessagePriority
Attributi

Campi

AboveNormal AboveNormal AboveNormal AboveNormal 4

Priorità dei messaggi tra High e Normal.Between High and Normal message priority.

High High High High 5

Priorità dei messaggi elevata.High message priority.

Highest Highest Highest Highest 7

Priorità dei messaggi massima.Highest message priority.

Low Low Low Low 2

Priorità dei messaggi bassa.Low message priority.

Lowest Lowest Lowest Lowest 0

Priorità dei messaggi minima.Lowest message priority.

Normal Normal Normal Normal 3

Priorità dei messaggi normale.Normal message priority.

VeryHigh VeryHigh VeryHigh VeryHigh 6

Priorità dei messaggi tra Highest e High.Between Highest and High message priority.

VeryLow VeryLow VeryLow VeryLow 1

Priorità dei messaggi tra Low e Lowest.Between Low and Lowest message priority.

Esempi

Nell'esempio seguente invia due messaggi con priorità diverse alla coda e successivamente recuperati.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;
}
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;
		}
	}
}
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

Commenti

Il MessagePriority enumerazione viene utilizzata per il Message della classe Priority proprietà.The MessagePriority enumeration is used by the Message class's Priority property. Questa proprietà influisce sul modo in cui il servizio Accodamento messaggi gestisce il messaggio sia durante l'indirizzamento e una volta raggiunta la destinazione.This property affects how Message Queuing handles the message both while it is en route and once it reaches its destination. I messaggi con priorità superiore hanno la precedenza durante l'instradamento e vengono inseriti nella parte anteriore della coda.Higher-priority messages are given preference during routing and inserted toward the front of the destination queue. I messaggi con la stessa priorità vengono inseriti nella coda in base all'ora di arrivo.Messages with the same priority are placed in the queue according to their arrival time.

Quando il servizio Accodamento messaggi instrada un messaggio a una coda pubblica, il livello di priorità del messaggio viene aggiunto al livello di priorità della coda pubblica (che è possibile accedere tramite il MessageQueue della classe BasePriority proprietà).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). Il livello di priorità della coda non ha effetto sul modo in cui vengono collocati i messaggi nella coda, solo sul modo in cui il servizio Accodamento messaggi gestisce il messaggio durante l'indirizzamento.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.

Priorità di base si applica solo alle code pubbliche.Base priority applies only to public queues. Per una coda privata, la priorità di base è sempre zero.For a private queue, the base priority is always zero.

È possibile impostare una priorità significativa solo per i messaggi non transazionali.You can set a meaningful priority only for non-transactional messages. Il servizio Accodamento messaggi che imposta la priorità per i messaggi transazionali per Lowest, in modo che la priorità deve essere ignorata.Message Queuing automatically sets the priority for transactional messages to Lowest, which causes transactional message priority to be ignored.

Si applica a

Vedi anche