MessageEnumerator Classe

Definizione

Fornisce un cursore forward-only per enumerare i messaggi in una coda di messaggi.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
Ereditarietà
MessageEnumerator
Implementazioni

Esempi

Nell'esempio seguente viene ottenuto un elenco dinamico di messaggi in una coda e vengono conteggiati tutti Priority i messaggi con MessagePriority.Lowestla proprietà impostata su.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

Commenti

Utilizzare MessageEnumerator per l'interazione dinamica con i messaggi in una coda.Use MessageEnumerator for dynamic interaction with messages in a queue. I metodi disponibili tramite MessageQueue la classe possono restituire un MessageEnumerator oggetto che punta a un elenco dinamico di messaggi nella coda o una matrice che contiene una copia in un determinato istante, ovvero uno snapshot della coda nel momento in cui è stato chiamato il metodo specificato.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.

Diversamente da uno snapshot statico, un enumeratore consente di modificare la raccolta.Unlike a static snapshot, an enumerator allows you to modify the collection. Utilizzando un MessageEnumeratorè possibile rimuovere i messaggi dalla coda e la modifica viene riflessa immediatamente nella coda.Using a MessageEnumerator, you can remove messages from the queue, and the change is immediately reflected in the queue.

Quando viene eseguita una query sulla coda, un enumeratore non rimuove i messaggi dalla coda.An enumerator does not remove the messages from the queue when it queries the queue. Restituisce informazioni sul messaggio in corrispondenza della posizione corrente del cursore, ma lascia il messaggio nella coda.It returns information about the message at the current cursor position, but it leaves the message in the queue.

Un MessageEnumerator oggetto è un cursore, inizializzato all'inizio di un elenco dinamico.A MessageEnumerator is a cursor, initialized to the head of a dynamic list. L'ordine dell'elenco corrisponde all'ordine dei messaggi nella coda, in base alla priorità del messaggio.The list order is the same as the order of the messages in the queue, according to message priority. È possibile spostare il cursore sul primo messaggio della coda chiamando MoveNext.You can move the cursor to the first message in the queue by calling MoveNext. Dopo che l'enumeratore è stato inizializzato, MoveNext è possibile utilizzare per procedere con i messaggi rimanenti.After the enumerator has been initialized, you can use MoveNext to step forward through the remaining messages. È possibile specificare se attendere che un messaggio diventi disponibile passando un timeout MoveNext al metodo.You can specify whether to wait for a message to become available by passing a timeout into the MoveNext method.

Poiché l'enumeratore è dinamico, l'enumeratore può accedere a un messaggio aggiunto oltre la posizione corrente del cursore, ad esempio a causa di priorità bassa.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. Non è possibile accedere A un messaggio inserito prima della posizione corrente del cursore.A message that is inserted before the cursor's current position cannot be accessed. Non è possibile eseguire l'istruzione precedente con un MessageEnumeratoroggetto.It is not possible to step backward with a MessageEnumerator. Un cursore consente lo spostamento di sola trasmissione.A cursor allows forward-only movement. Il Reset metodo consente di posizionare il cursore all'inizio della coda.The Reset method enables you to place the cursor back at the beginning of the queue.

Le istanze MessageEnumerator di per una determinata coda funzionano in modo indipendente.Instances of MessageEnumerator for a given queue work independently. È possibile creare due MessageEnumerator istanze di che si applicano alla stessa coda.You can create two MessageEnumerator instances that apply to the same queue. Le modifiche apportate MessageEnumerator ai messaggi nella coda saranno immediatamente riflesse in un secondo enumeratore se il secondo enumeratore è posizionato prima della prima.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. Tuttavia, se due enumeratori hanno la stessa posizione e uno di essi 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.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.

Nota

Se si crea un'istanza di MessageQueue con MessageQueue.DenySharedReceive impostato su true, nessun'altra applicazione può modificare i messaggi nell'enumeratore mentre è in corso la connessione alla coda.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.

Proprietà

Current

Ottiene il Message corrente cui punta questo enumeratore.Gets the current Message that this enumerator points to.

CursorHandle

Ottiene l'handle del cursore nativo di Accodamento messaggi utilizzato per visualizzare i messaggi della coda.Gets the native Message Queuing cursor handle used to browse messages in the queue.

Metodi

Close()

Rende disponibili le risorse associate all'enumeratore.Frees the resources associated with the enumerator.

CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Ereditato da MarshalByRefObject)
Dispose()

Rilascia tutte le risorse usate da MessageEnumerator.Releases all resources used by the MessageEnumerator.

Dispose(Boolean)

Rilascia le risorse non gestite usate da MessageEnumerator e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the MessageEnumerator and optionally releases the managed resources.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
Finalize()

Rilascia le risorse detenute dall'enumeratore.Releases the resources held by the enumerator.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Ereditato da MarshalByRefObject)
MoveNext()

Sposta l'enumeratore al messaggio successivo della coda, se ve n'è uno disponibile.Advances the enumerator to the next message in the queue, if one is currently available.

MoveNext(TimeSpan)

Sposta l'enumeratore al messaggio successivo della coda.Advances the enumerator to the next message in the queue. Se l'enumeratore si trova alla fine della coda, MoveNext() attende finché non scade il timeout o finché è disponibile un messaggio.If the enumerator is positioned at the end of the queue, MoveNext() waits until a message is available or the given timeout expires.

RemoveCurrent()

Rimuove il messaggio corrente da una coda transazionale o non transazionale e restituisce il messaggio all'applicazione che ha eseguito la chiamata.Removes the current message from a transactional or non-transactional queue and returns the message to the calling application. Non esistono timeout specifici per l'arrivo di un messaggio nella coda.There is no timeout specified for a message to arrive in the queue.

RemoveCurrent(MessageQueueTransaction)

Rimuove il messaggio corrente da una coda transazionale e restituisce il messaggio all'applicazione che ha eseguito la chiamata.Removes the current message from a transactional queue and returns the message to the calling application. Non esistono timeout specifici per l'arrivo di un messaggio nella coda.There is no timeout specified for a message to arrive in the queue.

RemoveCurrent(MessageQueueTransactionType)

Rimuove il messaggio corrente da una coda e restituisce il messaggio all'applicazione che ha eseguito la chiamata.Removes the current message from a queue and returns the message to the calling application. Non esistono timeout specifici per l'arrivo di un messaggio nella coda.There is no timeout specified for a message to arrive in the queue.

RemoveCurrent(TimeSpan)

Rimuove il messaggio corrente dalla coda e restituisce il messaggio all'applicazione che ha eseguito la chiamata.Removes the current message from the queue and returns the message to the calling application. Se è necessario rimuovere un messaggio, il metodo lo restituisce immediatamente.If there is a message to remove, the method returns it immediately. In caso contrario, il metodo attende il timeout specificato per l'arrivo di un nuovo messaggio.Otherwise, the method waits the specified timeout for a new message to arrive.

RemoveCurrent(TimeSpan, MessageQueueTransaction)

Rimuove il messaggio corrente da una coda transazionale e restituisce il messaggio all'applicazione che ha eseguito la chiamata.Removes the current message from a transactional queue and returns the message to the calling application. Se è necessario rimuovere un messaggio, il metodo lo restituisce immediatamente.If there is a message to remove, the method returns it immediately. In caso contrario, il metodo attende il timeout specificato per l'arrivo di un nuovo messaggio.Otherwise, the method waits the specified timeout for a new message to arrive.

RemoveCurrent(TimeSpan, MessageQueueTransactionType)

Rimuove il messaggio corrente da una coda e restituisce il messaggio all'applicazione che ha eseguito la chiamata.Removes the current message from a queue and returns the message to the calling application. Se è necessario rimuovere un messaggio, il metodo lo restituisce immediatamente.If there is a message to remove, the method returns it immediately. In caso contrario, il metodo attende il timeout specificato per l'arrivo di un nuovo messaggio.Otherwise, the method waits the specified timeout for a new message to arrive.

Reset()

Reimposta l'enumeratore corrente, in modo che punti all'inizio della coda.Resets the current enumerator so it points to the head of the queue.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IEnumerator.Current

Restituisce un oggetto Message che fa riferimento al messaggio nella posizione corrente del cursore.Returns a Message that references the message at the current cursor position.

Si applica a

Vedi anche