MessagePriority Enumeración

Definición

Especifica la prioridad que Message Queuing aplica a un mensaje mientras se encuentra en tránsito hacia una cola, y cuando inserta el mensaje en la cola de destino.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
Herencia
MessagePriority
Atributos

Campos

AboveNormal 4

Prioridad de mensaje entre High y Normal.Between High and Normal message priority.

High 5

Prioridad de mensaje alta.High message priority.

Highest 7

La prioridad de mensaje más alta.Highest message priority.

Low 2

Prioridad de mensaje baja.Low message priority.

Lowest 0

La prioridad de mensaje más baja.Lowest message priority.

Normal 3

Prioridad de mensaje normal.Normal message priority.

VeryHigh 6

Prioridad de mensaje entre Highest y High.Between Highest and High message priority.

VeryLow 1

Prioridad de mensaje entre Low y Lowest.Between Low and Lowest message priority.

Ejemplos

En el ejemplo siguiente se envían dos mensajes de prioridades diferentes a la cola y se recuperan posteriormente.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.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
      
      
      

      ' 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
      
      
      

      ' 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
   End Class

Comentarios

La MessagePriority propiedad de Message laPriority clase utiliza la enumeración.The MessagePriority enumeration is used by the Message class's Priority property. Esta propiedad afecta al modo en que Message Queuing controla el mensaje mientras se encuentra en la ruta y cuando llega a su destino.This property affects how Message Queuing handles the message both while it is en route and once it reaches its destination. Se da preferencia a los mensajes de alta prioridad durante el enrutamiento de mensajes, los cuales se insertan al principio de la cola de destino.Higher-priority messages are given preference during routing and inserted toward the front of the destination queue. Los mensajes que tienen la misma prioridad se colocan en la cola según su hora de llegada.Messages with the same priority are placed in the queue according to their arrival time.

Cuando Message Queuing envía un mensaje a una cola pública, el nivel de prioridad del mensaje se agrega al nivel de prioridad de la cola pública (a la que se puede MessageQueue tener acceso BasePriority a través de la propiedad de la clase).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). El nivel de prioridad de la cola no tiene ningún efecto en el modo en que los mensajes se colocan en la cola, solo en la forma en que Message Queuing controla el mensaje mientras está en la ruta.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.

La prioridad base se aplica solo a las colas públicas.Base priority applies only to public queues. En el caso de una cola privada, la prioridad base siempre es cero.For a private queue, the base priority is always zero.

Solo se puede establecer una prioridad significativa para los mensajes no transaccionales.You can set a meaningful priority only for non-transactional messages. Message Queue Server establece automáticamente la prioridad de los mensajes transaccionales en Lowest, lo que hace que se omita la prioridad de los mensajes transaccionales.Message Queuing automatically sets the priority for transactional messages to Lowest, which causes transactional message priority to be ignored.

Se aplica a

Consulte también: