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, deren Priority Eigenschaft auf 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

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

Im Gegensatz zu einem statischen Momentaufnahme können Sie mit einem Enumerator die Auflistung ändern. Mit einem MessageEnumeratorkönnen Sie Nachrichten aus der Warteschlange entfernen, und die Änderung wird sofort in der Warteschlange widerspiegelt.

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

A MessageEnumerator ist ein Cursor, der für den Kopf einer dynamischen Liste initialisiert wird. Die Listenreihenfolge entspricht der Reihenfolge der Nachrichten in der Warteschlange, entsprechend der Nachrichtenpriorität. Sie können den Cursor auf die erste Nachricht in der Warteschlange verschieben, indem Sie aufrufen MoveNext. Nachdem der Enumerator initialisiert wurde, können Sie verwenden MoveNext , um die verbleibenden Nachrichten weiterzuleiten. Sie können angeben, ob auf die Verfügbarkeit einer Nachricht gewartet werden soll, 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 einer niedrigen Priorität). Eine Nachricht, die vor der aktuellen Position des Cursors eingefügt wird, kann nicht zugegriffen werden. Es ist nicht möglich, mit einem MessageEnumeratorrückwärts zu treten. Ein Cursor ermöglicht eine Vorwärtsbewegung. Mit Reset der -Methode können Sie den Cursor wieder am Anfang der Warteschlange platzieren.

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

Eigenschaften

Methoden

Explizite Schnittstellenimplementierungen

Gilt für:

Weitere Informationen

• Message
• GetMessageEnumerator2()