MessagePriority Énumération

Définition

Espace de noms:

System.Messaging

Assembly:

System.Messaging.dll

Spécifie la priorité que Message Queuing applique à un message lors de son routage vers une file d'attente et lors de son insertion dans la file d'attente de destination.

C#

public enum MessagePriority

Héritage

Object

ValueType

Enum

MessagePriority

Champs

Nom	Valeur	Description
AboveNormal	4	Entre les priorités de message High et Normal.
High	5	Priorité de message élevée.
Highest	7	Priorité de message la plus élevée.
Low	2	Priorité de message faible.
Lowest	0	Priorité de message la plus faible.
Normal	3	Priorité de message normale.
VeryHigh	6	Entre les priorités de message Highest et High.
VeryLow	1	Entre les priorités de message Low et Lowest.

Exemples

L’exemple suivant envoie deux messages de priorités différentes à la file d’attente et les récupère par la suite.

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

Remarques

L’énumération MessagePriority est utilisée par la propriété de la MessagePriority classe . Cette propriété affecte la façon dont Message Queuing gère le message à la fois pendant qu’il est en route et une fois qu’il atteint sa destination. Les messages dont la priorité est la plus élevée sont prioritaires pendant le routage et sont insérés au début de la file d'attente de destination. Les messages de priorité identique sont placés dans la file d'attente en fonction de leur heure d'arrivée.

Lorsque Message Queuing achemine un message vers une file d’attente publique, le niveau de priorité du message est ajouté au niveau de priorité de la file d’attente publique (auquel vous pouvez accéder via la propriété de BasePriority la MessageQueue classe). Le niveau de priorité de la file d’attente n’a aucun effet sur la façon dont les messages sont placés dans la file d’attente, mais uniquement sur la façon dont Message Queuing gère le message pendant la route.

La priorité de base s’applique uniquement aux files d’attente publiques. Pour une file d’attente privée, la priorité de base est toujours égale à zéro.

Vous pouvez définir une priorité significative uniquement pour les messages non transactionnels. Message Queuing définit automatiquement la priorité des messages transactionnels sur Lowest, ce qui entraîne l’ignorer.

S’applique à

Voir aussi

• Priority
• BasePriority