MessagePriority MessagePriority MessagePriority MessagePriority Enum

Definition

Gibt die Priorität an, die Message Queuing einer Meldung auf dem Weg zu einer Warteschlange und beim Einfügen der Meldung in die Zielwarteschlage zuweist.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
Vererbung
MessagePriorityMessagePriorityMessagePriorityMessagePriority
Attribute

Felder

AboveNormal AboveNormal AboveNormal AboveNormal 4

Zwischen Meldungspriorität High und Normal.Between High and Normal message priority.

High High High High 5

Hohe Meldungspriorität.High message priority.

Highest Highest Highest Highest 7

Höchste Meldungspriorität.Highest message priority.

Low Low Low Low 2

Niedrige Meldungspriorität.Low message priority.

Lowest Lowest Lowest Lowest 0

Niedrigste Meldungspriorität.Lowest message priority.

Normal Normal Normal Normal 3

Normale Meldungspriorität.Normal message priority.

VeryHigh VeryHigh VeryHigh VeryHigh 6

Zwischen Meldungspriorität Highest und High.Between Highest and High message priority.

VeryLow VeryLow VeryLow VeryLow 1

Zwischen Meldungspriorität Low und Lowest.Between Low and Lowest message priority.

Beispiele

Im folgenden Beispiel werden zwei Nachrichten mit unterschiedlichen Prioritäten an die Warteschlange gesendet und anschließend abgerufen.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

Hinweise

Die MessagePriority -Enumeration wird von der Message -Eigenschaft Priority der-Klasse verwendet.The MessagePriority enumeration is used by the Message class's Priority property. Diese Eigenschaft wirkt sich darauf aus, wie Message Queuing die Nachricht sowohl während der Weiterleitung als auch nach Erreichen des Ziels behandelt.This property affects how Message Queuing handles the message both while it is en route and once it reaches its destination. Nachrichten höherer Priorität werden beim Routing bevorzugt und gegen Anfang der Zielwarteschlange eingefügt.Higher-priority messages are given preference during routing and inserted toward the front of the destination queue. Nachrichten mit der gleichen Priorität werden entsprechend ihrer Ankunftszeit in der Warteschlange platziert.Messages with the same priority are placed in the queue according to their arrival time.

Wenn Message Queuing eine Nachricht an eine öffentliche Warteschlange weiterleitet, wird die Prioritätsstufe der Nachricht der Prioritätsstufe der öffentlichen Warteschlange hinzugefügt (auf die über MessageQueue die- BasePriority Eigenschaft der-Klasse zugegriffen werden kann).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). Die Prioritäts Ebene der Warteschlange wirkt sich nicht darauf aus, wie Nachrichten in der Warteschlange platziert werden, sondern nur darauf, wie Message Queuing die Nachricht während der Route verarbeitet.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.

Die Basis Priorität gilt nur für öffentliche Warteschlangen.Base priority applies only to public queues. Bei einer privaten Warteschlange ist die Basis Priorität immer 0 (null).For a private queue, the base priority is always zero.

Sie können nur für nicht transaktionale Nachrichten eine sinnvolle Priorität festlegen.You can set a meaningful priority only for non-transactional messages. In Message Queuing wird die Priorität für Transaktionsnachrichten automatisch auf Lowestfestgelegt. Dies bewirkt, dass die Transaktionsnachrichten Priorität ignoriert wird.Message Queuing automatically sets the priority for transactional messages to Lowest, which causes transactional message priority to be ignored.

Gilt für:

Siehe auch