MessagePriority-Enumeration

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.

Namespace: System.Messaging
Assembly: System.Messaging (in system.messaging.dll)

Syntax

'Declaration
Public Enumeration MessagePriority
'Usage
Dim instance As MessagePriority

public enum MessagePriority

public enum class MessagePriority

public enum MessagePriority

public enum MessagePriority

Member

	Membername	Beschreibung
	AboveNormal	Zwischen Meldungspriorität High und Normal.
	High	Hohe Meldungspriorität.
	Highest	Höchste Meldungspriorität.
	Low	Niedrige Meldungspriorität.
	Lowest	Niedrigste Meldungspriorität.
	Normal	Normale Meldungspriorität.
	VeryHigh	Zwischen Meldungspriorität Highest und High.
	VeryLow	Zwischen Meldungspriorität Low und Lowest.

Hinweise

Die MessagePriority-Enumeration wird von der Priority-Eigenschaft der Message-Klasse verwendet. Diese Eigenschaft beeinflusst die Behandlung der Meldung in Message Queuing während der Übermittlung und beim Erreichen der Zielwarteschlange. Meldungen höherer Priorität werden beim Routing bevorzugt und gegen Anfang der Zielwarteschlange eingefügt. Meldungen mit derselben Priorität werden entsprechend ihrer Ankunftszeit in der Warteschlange platziert.

Wenn Message Queuing eine Meldung an eine öffentliche Warteschlange weiterleitet, wird die Prioritätsebene der Meldung der Prioritätsebene der öffentlichen Warteschlange hinzugefügt (auf diese kann mithilfe der BasePriority-Eigenschaft der MessageQueue-Klasse zugegriffen werden). Die Prioritätsebene der Warteschlange hat keine Auswirkung auf die Platzierung von Meldungen in der Warteschlange, sondern lediglich auf die Behandlung der Meldungen während des Routings durch Message Queuing.

Die Basispriorität wird nur auf öffentliche Warteschlangen angewendet. Bei privaten Warteschlangen ist die Basispriorität immer 0.

Ein Festlegen der Priorität ist nur für nicht transaktionale Meldungen sinnvoll. Für transaktionale Meldungen legt Message Queuing die Priorität automatisch auf Lowest fest, sodass die Priorität dieser Meldungen ignoriert wird.

Beispiel

Im folgenden Beispiel werden zwei Meldungen mit verschiedenen Prioritäten an die Warteschlange gesendet und nacheinander abgerufen.

Imports System
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 'Main
      
      
      

      ' 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 'SendMessage
      
      
      

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

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

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

package MyProject;

import System.*;
import System.Messaging.*;

/// <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(String[] args)
    {
        // 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;
    } //main

    //**************************************************
    // 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.CompareTo(MessagePriority.Normal) > 0) {
            myMessage.set_Body("High Priority: " + messageBody);
        }
        else {
            myMessage.set_Body(messageBody);
        }
        // Set the priority of the message.
        myMessage.set_Priority(priority);
        // Send the Order to the queue.
        myQueue.Send(myMessage);
        return;
    } //SendMessage

    //**************************************************
    // 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.get_MessageReadPropertyFilter().set_Priority(true);
        // Set the formatter to indicate body contains a string.
        myQueue.set_Formatter(new XmlMessageFormatter(new Type[]
            { String.class.ToType() }));
        try {
            // Receive and format the message. 
            Message myMessage = myQueue.Receive();
            // Display message information.
            Console.WriteLine("Priority: " + myMessage.get_Priority().ToString());
            Console.WriteLine("Body: " + myMessage.get_Body().ToString());
        }
        catch (MessageQueueException exp) {
            // Handle Message Queuing exceptions.
        }            
        // Handle invalid serialization format.
        catch (InvalidOperationException e) {
            Console.WriteLine(e.get_Message());
        }
        // Catch other exceptions as necessary.
        return;
    } //ReceiveMessage
} //MyNewQueue

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0

Siehe auch

Referenz

System.Messaging-Namespace
Message.Priority-Eigenschaft
MessageQueue.BasePriority