MessagePriority Enumeração

Definição

Namespace:

System.Messaging

Assembly:

System.Messaging.dll

Especifica que a prioridade Enfileiramento de Mensagens aplica-se a uma mensagem enquanto ela estiver em trânsito para uma fila e ao inserir a mensagem na fila de destino.

C#

public enum MessagePriority

Herança

Object

ValueType

Enum

MessagePriority

Campos

Nome	Valor	Description
AboveNormal	4	Entre a prioridade de mensagem High e Normal.
High	5	Prioridade de mensagem alta.
Highest	7	Maior prioridade de mensagem.
Low	2	Prioridade de mensagem baixa.
Lowest	0	Menor prioridade de mensagem.
Normal	3	Prioridade de mensagem normal.
VeryHigh	6	Entre a prioridade de mensagem Highest e High.
VeryLow	1	Entre a prioridade de mensagem Low e Lowest.

Exemplos

O exemplo a seguir envia duas mensagens de prioridades diferentes para a fila e as recupera posteriormente.

C#

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;
        }
    }
}

Comentários

A MessagePriority enumeração é usada pela Message propriedade da Priority classe. Essa propriedade afeta como o Enfileiramento de Mensagens manipula a mensagem enquanto ela está no caminho e quando chega ao seu destino. As mensagens de prioridade mais alta recebem preferência durante o roteamento e são inseridas na frente da fila de destino. As mensagens com a mesma prioridade são colocadas na fila de acordo com a hora de chegada.

Quando o Enfileiramento de Mensagens roteia uma mensagem para uma fila pública, o nível de prioridade da mensagem é adicionado ao nível de prioridade da fila pública (que você pode acessar por meio da MessageQueue propriedade da BasePriority classe). O nível de prioridade da fila não tem efeito sobre como as mensagens são colocadas na fila, somente sobre como o Enfileiramento de Mensagens manipula a mensagem enquanto está no caminho.

A prioridade base se aplica somente a filas públicas. Para uma fila privada, a prioridade base é sempre zero.

Você pode definir uma prioridade significativa somente para mensagens não transacionais. O Enfileiramento de Mensagens define automaticamente a prioridade das mensagens transacionais como Lowest, o que faz com que a prioridade da mensagem transacional seja ignorada.

Aplica-se a

Confira também

• Priority
• BasePriority