MessageEnumerator Klasse

Referenz

Definition

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt einen Vorwärtscursor zum Aufzählen der Nachrichten in einer Nachrichtenwarteschlange bereit.

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 eine MessageEnumerator dynamische Liste von Nachrichten in der Warteschlange oder ein Array zurückgeben, das eine Kopie in einem bestimmten Moment enthält – eine Momentaufnahme – der Warteschlange zum Zeitpunkt des Aufrufs der angegebenen Methode.

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

Eine Aufzählung entfernt die Nachrichten nicht aus der Warteschlange, wenn sie die Warteschlange abfragt. Es gibt Informationen über die Nachricht an der aktuellen Cursorposition zurück, aber sie verlässt die Nachricht in der Warteschlange.

A MessageEnumerator ist ein Cursor, der an 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 in die erste Nachricht in der Warteschlange verschieben, indem Sie aufrufen MoveNext. Nachdem die Aufzählung initialisiert wurde, können MoveNext Sie die verbleibenden Nachrichten durchlaufen. Sie können angeben, ob eine Nachricht warten soll, um verfügbar zu werden, indem Sie ein Timeout an die MoveNext Methode übergeben.

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

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

Hinweis

Wenn Sie eine Instanz mit MessageQueue MessageQueue.DenySharedReceive "Set" trueerstellen, kann keine andere Anwendung die Nachrichten in Ihrer Aufzählung ändern, während Sie über die Verbindung mit der Warteschlange verfügen.

Eigenschaften

Current	Ruft das aktuelle Message ab, auf das dieser Enumerator zeigt.
CursorHandle	Ruft das systemeigene Cursorhandle von Message Queuing ab, das zum Durchsuchen von Meldungen in der Warteschlange verwendet wird.

Methoden

Close()	Gibt die dem Enumerator zugeordneten Ressourcen frei.
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
Dispose()	Gibt alle vom MessageEnumerator verwendeten Ressourcen frei.
Dispose(Boolean)	Gibt die von MessageEnumerator verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
Finalize()	Diese API unterstützt die Produktinfrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code gedacht. Gibt die von diesem Enumerator reservierten Ressourcen frei.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
MoveNext()	Setzt den Enumerator auf die nächste Meldung in der Warteschlange, sofern eine Meldung verfügbar ist.
MoveNext(TimeSpan)	Setzt den Enumerator auf die nächste Meldung in der Warteschlange. Wenn sich der Enumerator am Ende der Warteschlange befindet, wartet MoveNext(), bis eine Meldung verfügbar ist oder der angegebene Timeout überschritten wird.
RemoveCurrent()	Entfernt die aktuelle Meldung aus einer transaktionalen oder nicht transaktionalen Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück. Für das Eintreffen einer Meldung in der Warteschlange ist kein Timeout festgelegt.
RemoveCurrent(MessageQueueTransaction)	Entfernt die aktuelle Meldung aus einer transaktionalen Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück. Für das Eintreffen einer Meldung in der Warteschlange ist kein Timeout festgelegt.
RemoveCurrent(MessageQueueTransactionType)	Entfernt die aktuelle Meldung aus einer Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück. Für das Eintreffen einer Meldung in der Warteschlange ist kein Timeout festgelegt.
RemoveCurrent(TimeSpan)	Entfernt die aktuelle Meldung aus der Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück. Wenn eine vorhandene Meldung entfernt werden kann, wird diese von der Methode sofort zurückgegeben. Andernfalls wartet die Methode auf das Eingehen einer neuen Meldung, bis der angegebene Timeout überschritten wird.
RemoveCurrent(TimeSpan, MessageQueueTransaction)	Entfernt die aktuelle Meldung aus einer transaktionalen Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück. Wenn eine vorhandene Meldung entfernt werden kann, wird diese von der Methode sofort zurückgegeben. Andernfalls wartet die Methode auf das Eingehen einer neuen Meldung, bis der angegebene Timeout überschritten wird.
RemoveCurrent(TimeSpan, MessageQueueTransactionType)	Entfernt die aktuelle Meldung aus einer Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück. Wenn eine vorhandene Meldung entfernt werden kann, wird diese von der Methode sofort zurückgegeben. Andernfalls wartet die Methode auf das Eingehen einer neuen Meldung, bis der angegebene Timeout überschritten wird.
Reset()	Setzt den aktuellen Enumerator auf den Anfang der Warteschlange zurück.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

IEnumerator.Current

Gibt eine Message zurück, die auf die Meldung an der aktuellen Cursorposition verweist.

Gilt für