MessagePriority Énumération
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
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.
public enum class MessagePrioritypublic enum MessagePrioritytype MessagePriority = Public Enum MessagePriority- Héritage
Champs
| AboveNormal | 4 | |
| 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 |
| VeryLow | 1 | Entre les priorités de message |
Exemples
L’exemple suivant envoie deux messages de priorités différentes à la file d’attente et les récupère par la suite.
#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
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.
