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, 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.

Hinweis

Wenn Sie eine instance von mit MessageQueue MessageQueue.DenySharedReceive festgelegt auf trueerstellen, kann keine andere Anwendung die Nachrichten in Ihrem Enumerator ändern, während Sie eine Verbindung mit der Warteschlange haben.

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:

Freigeben über