MessageEnumerator Classe

Definizione

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

Ereditarietà

Object

MarshalByRefObject

MessageEnumerator

Implementazioni

IEnumerator IDisposable

Esempio

L'esempio seguente ottiene un elenco dinamico di messaggi in una coda e conta tutti i messaggi con la Priority proprietà impostata su 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

Commenti

Usare MessageEnumerator per l'interazione dinamica con i messaggi in una coda. I metodi disponibili tramite la MessageQueue classe possono restituire un MessageEnumerator elenco dinamico di messaggi nella coda o una matrice che contiene una copia in un determinato istante, ovvero uno snapshot, della coda al momento della chiamata al metodo specificato.

A differenza di uno snapshot statico, un enumeratore consente di modificare la raccolta. Usando , MessageEnumeratorè possibile rimuovere i messaggi dalla coda e la modifica viene immediatamente riflessa nella coda.

Un enumeratore non rimuove i messaggi dalla coda quando esegue una query sulla coda. Restituisce informazioni sul messaggio nella posizione corrente del cursore, ma lascia il messaggio nella coda.

Un MessageEnumerator oggetto è un cursore, inizializzato all'inizio di un elenco dinamico. L'ordine di elenco corrisponde all'ordine dei messaggi nella coda, in base alla priorità del messaggio. È possibile spostare il cursore al primo messaggio nella coda chiamando MoveNext. Dopo l'inizializzazione dell'enumeratore, è possibile usare MoveNext per eseguire i messaggi rimanenti. È possibile specificare se attendere che un messaggio diventi disponibile passando un timeout nel MoveNext metodo .

Poiché l'enumeratore è dinamico, è possibile accedere a un messaggio che viene aggiunto oltre la posizione corrente del cursore, ad esempio a causa della priorità bassa, dall'enumeratore. Non è possibile accedere a un messaggio inserito prima che non sia possibile accedere alla posizione corrente del cursore. Non è possibile eseguire un'istruzione indietro con un oggetto MessageEnumerator. Un cursore consente lo spostamento forward-only. Il Reset metodo consente di posizionare nuovamente il cursore all'inizio della coda.

Istanze di MessageEnumerator per un determinato lavoro in coda in modo indipendente. È possibile creare due MessageEnumerator istanze che si applicano alla stessa coda. Le modifiche apportate MessageEnumerator ai messaggi nella coda verranno riflesse immediatamente in un secondo enumeratore se il secondo enumeratore viene posizionato prima del primo. Tuttavia, se due enumeratori hanno la stessa posizione e una di esse rimuove il messaggio in tale posizione, viene generata un'eccezione se l'altro enumeratore tenta di ottenere il valore della Current proprietà nel messaggio eliminato.

Proprietà

Metodi

Implementazioni dell'interfaccia esplicita

Si applica a

Vedi anche

• Message
• GetMessageEnumerator2()