MessageEnumerator Klasse

Definition

Stellt einen Vorwärtscursor zum Durchlaufen der Meldungen in einer Meldungswarteschlange bereit.Provides a forward-only cursor to enumerate through messages in a message queue.

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
MessageEnumerator
Implementiert

Beispiele

Im folgenden Beispiel wird eine dynamische Liste von Nachrichten in einer Warteschlange abgerufen und alle nach Priority richten gezählt, MessagePriority.Lowestderen-Eigenschaft auf festgelegt ist.The following example gets a dynamic list of messages in a queue and counts all messages with the Priority property set to 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 MessageEnumerator Sie für die dynamische Interaktion mit Nachrichten in einer Warteschlange.Use MessageEnumerator for dynamic interaction with messages in a queue. Methoden, die über MessageQueue die-Klasse verfügbar sind MessageEnumerator , können entweder eine, die auf eine dynamische Liste von Nachrichten in der Warteschlange zeigt, oder ein Array, das eine Kopie zu einem bestimmten Zeitpunkt enthält, eine Momentaufnahme der Warteschlange zum Zeitpunkt des Aufrufs der angegebenen Methode zurückgeben.Methods available through the MessageQueue class can return either a MessageEnumerator pointing to a dynamic list of messages in the queue, or an array that contains a copy at a given instant - a snapshot - of the queue at the time the specified method was called.

Anders als eine statische Momentaufnahme ermöglicht ein Enumerator das Ändern der Auflistung.Unlike a static snapshot, an enumerator allows you to modify the collection. Mithilfe eines MessageEnumeratorkönnen Sie Nachrichten aus der Warteschlange entfernen, und die Änderung wird sofort in der Warteschlange widergespiegelt.Using a MessageEnumerator, you can remove messages from the queue, and the change is immediately reflected in the queue.

Ein Enumerator entfernt die Nachrichten nicht aus der Warteschlange, wenn er die Warteschlange abfragt.An enumerator does not remove the messages from the queue when it queries the queue. Sie gibt Informationen über die Nachricht an der aktuellen Cursorposition zurück, aber die Nachricht wird in der Warteschlange belassen.It returns information about the message at the current cursor position, but it leaves the message in the queue.

Ein MessageEnumerator ist ein Cursor, der mit dem Anfang einer dynamischen Liste initialisiert wird.A MessageEnumerator is a cursor, initialized to the head of a dynamic list. Die Reihenfolge der Listen ist mit der Reihenfolge der Nachrichten in der Warteschlange entsprechend der Nachrichten Priorität identisch.The list order is the same as the order of the messages in the queue, according to message priority. Sie können den Cursor zur ersten Nachricht in der Warteschlange bewegen, indem MoveNextSie aufrufen.You can move the cursor to the first message in the queue by calling MoveNext. Nachdem der Enumerator initialisiert wurde, können Sie verwenden MoveNext , um die restlichen Nachrichten schrittweise zu durchlaufen.After the enumerator has been initialized, you can use MoveNext to step forward through the remaining messages. Sie können angeben, ob auf die Verfügbarkeit einer Nachricht gewartet werden soll, indem Sie ein MoveNext Timeout an die-Methode übergeben.You can specify whether to wait for a message to become available by passing a timeout into the MoveNext method.

Da der Enumerator dynamisch ist, kann eine Nachricht, die über die aktuelle Position des Cursors (z. b. aufgrund niedriger Priorität) angefügt wird, durch den Enumerator aufgerufen werden.Because the enumerator is dynamic, a message that is appended beyond the cursor's current position (for example, due to low priority), can be accessed by the enumerator. Auf eine Meldung, die vor der aktuellen Position des Cursors eingefügt wird, kann nicht zugegriffen werden.A message that is inserted before the cursor's current position cannot be accessed. Es ist nicht möglich, mit einem MessageEnumeratorrückwärts zu wechseln.It is not possible to step backward with a MessageEnumerator. Ein Cursor ermöglicht Vorwärtsbewegung.A cursor allows forward-only movement. Mit Reset der-Methode können Sie den Cursor am Anfang der Warteschlange wieder platzieren.The Reset method enables you to place the cursor back at the beginning of the queue.

Instanzen von MessageEnumerator für eine bestimmte Warteschlange funktionieren unabhängig voneinander.Instances of MessageEnumerator for a given queue work independently. Sie können zwei MessageEnumerator -Instanzen erstellen, die für dieselbe Warteschlange gelten.You can create two MessageEnumerator instances that apply to the same queue. Die Änderungen, die MessageEnumerator an den Nachrichten in der Warteschlange vorgenommen werden, werden sofort in einem zweiten Enumerator reflektiert, wenn der zweite Enumerator vor dem ersten positioniert ist.The changes that one MessageEnumerator makes to the messages in the queue will be reflected immediately in a second enumerator if the second enumerator is positioned before the first. Wenn jedoch zwei Enumeratoren dieselbe Position haben und eine von Ihnen an dieser Position entfernt wird, wird eine Ausnahme ausgelöst, wenn der andere Enumerator versucht, den Wert der Current -Eigenschaft für die nun gelöschte Nachricht zu erhalten.However, if two enumerators have the same position and one of them removes the message at that position, an exception is thrown if the other enumerator attempts to get the value of the Current property on the now-deleted message.

Hinweis

Wenn Sie eine Instanz von MessageQueue erstellen, bei MessageQueue.DenySharedReceive der trueauf festgelegt ist, kann keine andere Anwendung die Nachrichten in Ihrem Enumerator ändern, während Sie die Verbindung zur Warteschlange haben.If you create an instance of MessageQueue with MessageQueue.DenySharedReceive set to true, no other application can modify the messages in your enumerator while you have the connection to the queue.

Eigenschaften

Current

Ruft das aktuelle Message ab, auf das dieser Enumerator zeigt.Gets the current Message that this enumerator points to.

CursorHandle

Ruft das systemeigene Cursorhandle von Message Queuing ab, das zum Durchsuchen von Meldungen in der Warteschlange verwendet wird.Gets the native Message Queuing cursor handle used to browse messages in the queue.

Methoden

Close()

Gibt die dem Enumerator zugeordneten Ressourcen frei.Frees the resources associated with the enumerator.

CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Geerbt von MarshalByRefObject)
Dispose()

Gibt alle vom MessageEnumerator verwendeten Ressourcen frei.Releases all resources used by the MessageEnumerator.

Dispose(Boolean)

Gibt die von MessageEnumerator verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.Releases the unmanaged resources used by the MessageEnumerator and optionally releases the managed resources.

Equals(Object)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
Finalize()

Gibt die von diesem Enumerator reservierten Ressourcen frei.Releases the resources held by the enumerator.

GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetLifetimeService()

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
InitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.Obtains a lifetime service object to control the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.Creates a shallow copy of the current MarshalByRefObject object.

(Geerbt von MarshalByRefObject)
MoveNext()

Setzt den Enumerator auf die nächste Meldung in der Warteschlange, sofern eine Meldung verfügbar ist.Advances the enumerator to the next message in the queue, if one is currently available.

MoveNext(TimeSpan)

Setzt den Enumerator auf die nächste Meldung in der Warteschlange.Advances the enumerator to the next message in the queue. Wenn sich der Enumerator am Ende der Warteschlange befindet, wartet MoveNext(), bis eine Meldung verfügbar ist oder der angegebene Timeout überschritten wird.If the enumerator is positioned at the end of the queue, MoveNext() waits until a message is available or the given timeout expires.

RemoveCurrent()

Entfernt die aktuelle Meldung aus einer transaktionalen oder nicht transaktionalen Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück.Removes the current message from a transactional or non-transactional queue and returns the message to the calling application. Für das Eintreffen einer Meldung in der Warteschlange ist kein Timeout festgelegt.There is no timeout specified for a message to arrive in the queue.

RemoveCurrent(MessageQueueTransaction)

Entfernt die aktuelle Meldung aus einer transaktionalen Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück.Removes the current message from a transactional queue and returns the message to the calling application. Für das Eintreffen einer Meldung in der Warteschlange ist kein Timeout festgelegt.There is no timeout specified for a message to arrive in the queue.

RemoveCurrent(MessageQueueTransactionType)

Entfernt die aktuelle Meldung aus einer Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück.Removes the current message from a queue and returns the message to the calling application. Für das Eintreffen einer Meldung in der Warteschlange ist kein Timeout festgelegt.There is no timeout specified for a message to arrive in the queue.

RemoveCurrent(TimeSpan)

Entfernt die aktuelle Meldung aus der Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück.Removes the current message from the queue and returns the message to the calling application. Wenn eine vorhandene Meldung entfernt werden kann, wird diese von der Methode sofort zurückgegeben.If there is a message to remove, the method returns it immediately. Andernfalls wartet die Methode auf das Eingehen einer neuen Meldung, bis der angegebene Timeout überschritten wird.Otherwise, the method waits the specified timeout for a new message to arrive.

RemoveCurrent(TimeSpan, MessageQueueTransaction)

Entfernt die aktuelle Meldung aus einer transaktionalen Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück.Removes the current message from a transactional queue and returns the message to the calling application. Wenn eine vorhandene Meldung entfernt werden kann, wird diese von der Methode sofort zurückgegeben.If there is a message to remove, the method returns it immediately. Andernfalls wartet die Methode auf das Eingehen einer neuen Meldung, bis der angegebene Timeout überschritten wird.Otherwise, the method waits the specified timeout for a new message to arrive.

RemoveCurrent(TimeSpan, MessageQueueTransactionType)

Entfernt die aktuelle Meldung aus einer Warteschlange und gibt die Meldung an die aufrufende Anwendung zurück.Removes the current message from a queue and returns the message to the calling application. Wenn eine vorhandene Meldung entfernt werden kann, wird diese von der Methode sofort zurückgegeben.If there is a message to remove, the method returns it immediately. Andernfalls wartet die Methode auf das Eingehen einer neuen Meldung, bis der angegebene Timeout überschritten wird.Otherwise, the method waits the specified timeout for a new message to arrive.

Reset()

Setzt den aktuellen Enumerator auf den Anfang der Warteschlange zurück.Resets the current enumerator so it points to the head of the queue.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

IEnumerator.Current

Gibt eine Message zurück, die auf die Meldung an der aktuellen Cursorposition verweist.Returns a Message that references the message at the current cursor position.

Gilt für:

Siehe auch