MessageEnumerator Klasse

Definition

public ref class MessageEnumerator : MarshalByRefObject, IDisposable, System::Collections::IEnumerator

public class MessageEnumerator : MarshalByRefObject, IDisposable, System.Collections.IEnumerator

type MessageEnumerator = class
    inherit MarshalByRefObject
    interface IEnumerator
    interface IDisposable

Public Class MessageEnumerator
Inherits MarshalByRefObject
Implements IDisposable, IEnumerator

Vererbung

Object

MarshalByRefObject

MessageEnumerator

Implementiert

IEnumerator IDisposable

Beispiele

Das folgende Beispiel ruft eine dynamische Liste von Nachrichten in einer Warteschlange ab und zählt alle Nachrichten, auf die die Priority Eigenschaft festgelegt ist MessagePriority.Lowest.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
   void CountLowestPriority()
   {
      
      // Holds the count of Lowest priority messages.
      UInt32 numberItems = 0;
      
      // Connect to a queue.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      
      // Get a cursor into the messages in the queue.
      MessageEnumerator^ myEnumerator = myQueue->GetMessageEnumerator();
      
      // Specify that the messages's priority should be read.
      myQueue->MessageReadPropertyFilter->Priority = true;
      
      // Move to the next message and examine its priority.
      while ( myEnumerator->MoveNext() )
      {
         
         // Increase the count if priority is Lowest.
         if ( myEnumerator->Current->Priority == MessagePriority::Lowest )
                  numberItems++;
      }

      
      // Display final count.
      Console::WriteLine( "Lowest priority messages: {0}", numberItems );
      return;
   }

};

int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Output the count of Lowest priority messages.
   myNewQueue->CountLowestPriority();
   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 uses a cursor to step through the
        // messages in a queue and counts the number of
        // Lowest priority messages.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Output the count of Lowest priority messages.
            myNewQueue.CountLowestPriority();
                        
            return;
        }

        //**************************************************
        // Iterates through messages in a queue and examines
        // their priority.
        //**************************************************
        
        public void CountLowestPriority()
        {
            // Holds the count of Lowest priority messages.
            uint numberItems = 0;

            // Connect to a queue.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
    
            // Get a cursor into the messages in the queue.
            MessageEnumerator myEnumerator =
                myQueue.GetMessageEnumerator();

            // Specify that the messages's priority should be read.
            myQueue.MessageReadPropertyFilter.Priority = true;

            // Move to the next message and examine its priority.
            while(myEnumerator.MoveNext())
            {
                // Increase the count if priority is Lowest.
                if(myEnumerator.Current.Priority ==
                    MessagePriority.Lowest)
                    
                    numberItems++;
            }

            // Display final count.
            Console.WriteLine("Lowest priority messages: " +
                numberItems.ToString());
            
            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        
        ' Provides an entry point into the application.
        '		 
        ' This example uses a cursor to step through the
        ' messages in a queue and counts the number of 
        ' Lowest priority messages.
        

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Output the count of Lowest priority messages.
            myNewQueue.CountLowestPriority()

            Return

        End Sub


        
        ' Iterates through messages in a queue and examines
        ' their priority.
        

        Public Sub CountLowestPriority()

            ' Holds the count of Lowest priority messages.
            Dim numberItems As Int32 = 0

            ' Connect to a queue.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Get a cursor into the messages in the queue.
            Dim myEnumerator As MessageEnumerator = _
                myQueue.GetMessageEnumerator()

            ' Specify that the messages's priority should be read.
            myQueue.MessageReadPropertyFilter.Priority = True

            ' Move to the next message and examine its priority.
            While myEnumerator.MoveNext()

                ' Increase the count if the priority is Lowest.
                If myEnumerator.Current.Priority = _
                    MessagePriority.Lowest Then
                    numberItems += 1
                End If

            End While

            ' Display final count.
            Console.WriteLine(("Lowest priority messages: " + _
                numberItems.ToString()))

            Return

        End Sub

End Class

Hinweise

Wird für dynamische Interaktion mit Nachrichten in einer Warteschlange verwendet MessageEnumerator . Methoden, die über die MessageQueue Klasse verfügbar sind, können entweder einen MessageEnumerator Zeiger auf eine dynamische Liste von Nachrichten in der Warteschlange oder ein Array zurückgeben, das eine Kopie zu einem bestimmten Zeitpunkt enthält – eine Momentaufnahme – der Warteschlange zum Zeitpunkt des Aufrufs der angegebenen Methode.

Im Gegensatz zu einer statischen Momentaufnahme können Sie mit einem Enumerator die Auflistung ändern. Mithilfe eines MessageEnumerator, können Sie Nachrichten aus der Warteschlange entfernen, und die Änderung wird sofort in der Warteschlange angezeigt.

Ein Enumerator entfernt die Nachrichten nicht aus der Warteschlange, wenn sie die Warteschlange abfragt. Sie gibt Informationen zur Nachricht an der aktuellen Cursorposition zurück, die Nachricht bleibt jedoch in der Warteschlange.

A MessageEnumerator ist ein Cursor, der an den Kopf einer dynamischen Liste initialisiert ist. Die Listenreihenfolge entspricht der Reihenfolge der Nachrichten in der Warteschlange entsprechend der Nachrichtenpriorität. Sie können den Cursor in die erste Nachricht in der Warteschlange verschieben, indem Sie die Warteschlange aufrufen MoveNext. Nachdem der Enumerator initialisiert wurde, können Sie die MoveNext verbleibenden Nachrichten schrittweise durchgehen. Sie können angeben, ob gewartet werden soll, bis eine Nachricht verfügbar ist, indem Sie ein Timeout an die MoveNext Methode übergeben.

Da der Enumerator dynamisch ist, kann vom Enumerator auf eine Nachricht zugegriffen werden, die über die aktuelle Position des Cursors hinaus angefügt wird (z. B. aufgrund niedriger Priorität). Auf eine Nachricht, die vor der aktuellen Position des Cursors eingefügt wird, kann nicht zugegriffen werden. Es ist nicht möglich, mit einem MessageEnumerator. Ein Cursor ermöglicht vorwärtsgerichtete Bewegungen. Mit der Reset Methode können Sie den Cursor wieder am Anfang der Warteschlange platzieren.

MessageEnumerator Instanzen einer bestimmten Warteschlange funktionieren unabhängig voneinander. Sie können zwei MessageEnumerator Instanzen erstellen, die für dieselbe Warteschlange gelten. Die Änderungen, die man MessageEnumerator an den Nachrichten in der Warteschlange vorgibt, werden sofort in einem zweiten Enumerationsgeber angezeigt, wenn der zweite Enumerator vor dem ersten positioniert wird. Wenn jedoch zwei Enumeratoren dieselbe Position haben und eine davon die Nachricht an dieser Position entfernt, wird eine Ausnahme ausgelöst, wenn der andere Enumerator versucht, den Wert der Current Eigenschaft für die jetzt gelöschte Nachricht abzurufen.

Weitere Informationen

• Message
• GetMessageEnumerator2()