MessageEnumerator Classe

Riferimento

Definizione

Spazio dei nomi:: System.Messaging

Assembly:: System.Messaging.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Fornisce un cursore forward-only per enumerare i messaggi in una coda di messaggi.

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.

Nota

Se si crea un'istanza di MessageQueue con MessageQueue.DenySharedReceive impostato su true, nessun'altra applicazione può modificare i messaggi nell'enumeratore mentre si dispone della connessione alla coda.

Proprietà

Current	Ottiene il Message corrente cui punta questo enumeratore.
CursorHandle	Ottiene l'handle del cursore nativo di Accodamento messaggi utilizzato per visualizzare i messaggi della coda.

Metodi

Close()	Rende disponibili le risorse associate all'enumeratore.
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. (Ereditato da MarshalByRefObject)
Dispose()	Rilascia tutte le risorse usate da MessageEnumerator.
Dispose(Boolean)	Rilascia le risorse non gestite usate da MessageEnumerator e, facoltativamente, le risorse gestite.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Finalize()	Questa API supporta l'infrastruttura del prodotto e non è previsto che venga usata direttamente dal codice. Rilascia le risorse detenute dall'enumeratore.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
MoveNext()	Sposta l'enumeratore al messaggio successivo della coda, se ve n'è uno disponibile.
MoveNext(TimeSpan)	Sposta l'enumeratore al messaggio successivo della coda. Se l'enumeratore si trova alla fine della coda, MoveNext() attende finché non scade il timeout o finché è disponibile un messaggio.
RemoveCurrent()	Rimuove il messaggio corrente da una coda transazionale o non transazionale e restituisce il messaggio all'applicazione che ha eseguito la chiamata. Non esistono timeout specifici per l'arrivo di un messaggio nella coda.
RemoveCurrent(MessageQueueTransaction)	Rimuove il messaggio corrente da una coda transazionale e restituisce il messaggio all'applicazione che ha eseguito la chiamata. Non esistono timeout specifici per l'arrivo di un messaggio nella coda.
RemoveCurrent(MessageQueueTransactionType)	Rimuove il messaggio corrente da una coda e restituisce il messaggio all'applicazione che ha eseguito la chiamata. Non esistono timeout specifici per l'arrivo di un messaggio nella coda.
RemoveCurrent(TimeSpan)	Rimuove il messaggio corrente dalla coda e restituisce il messaggio all'applicazione che ha eseguito la chiamata. Se è necessario rimuovere un messaggio, il metodo lo restituisce immediatamente. In caso contrario, il metodo attende il timeout specificato per l'arrivo di un nuovo messaggio.
RemoveCurrent(TimeSpan, MessageQueueTransaction)	Rimuove il messaggio corrente da una coda transazionale e restituisce il messaggio all'applicazione che ha eseguito la chiamata. Se è necessario rimuovere un messaggio, il metodo lo restituisce immediatamente. In caso contrario, il metodo attende il timeout specificato per l'arrivo di un nuovo messaggio.
RemoveCurrent(TimeSpan, MessageQueueTransactionType)	Rimuove il messaggio corrente da una coda e restituisce il messaggio all'applicazione che ha eseguito la chiamata. Se è necessario rimuovere un messaggio, il metodo lo restituisce immediatamente. In caso contrario, il metodo attende il timeout specificato per l'arrivo di un nuovo messaggio.
Reset()	Reimposta l'enumeratore corrente, in modo che punti all'inizio della coda.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IEnumerator.Current

Restituisce un oggetto Message che fa riferimento al messaggio nella posizione corrente del cursore.

Si applica a

Condividi tramite