MessageQueueEnumerator 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 MessageQueueEnumerator : MarshalByRefObject, IDisposable, System::Collections::IEnumerator
public class MessageQueueEnumerator : MarshalByRefObject, IDisposable, System.Collections.IEnumerator
type MessageQueueEnumerator = class
    inherit MarshalByRefObject
    interface IEnumerator
    interface IDisposable
Public Class MessageQueueEnumerator
Inherits MarshalByRefObject
Implements IDisposable, IEnumerator
Ereditarietà
MessageQueueEnumerator
Implementazioni

Esempi

Nell'esempio di codice seguente viene eseguita l'iterazione di tutte le code di messaggi in rete e viene esaminato il percorso di ogni coda.The following code example iterates through all the message queues in the network, and examines the path for each queue. Infine, viene visualizzato il numero di code pubbliche sulla rete.Finally, it displays the number of public queues on the network.

#using <System.dll>
#using <System.Messaging.dll>

using namespace System;
using namespace System::Messaging;

//**************************************************
// Iterates through message queues and examines the
// path for each queue. Also displays the number of
// public queues on the network.
//**************************************************
void ListPublicQueues()
{
   
   // Holds the count of private queues.
   int numberQueues = 0;
   
   // Get a cursor into the queues on the network.
   MessageQueueEnumerator^ myQueueEnumerator = MessageQueue::GetMessageQueueEnumerator();
   
   // Move to the next queue and read its path.
   while ( myQueueEnumerator->MoveNext() )
   {
      
      // Increase the count if priority is Lowest.
      Console::WriteLine( myQueueEnumerator->Current->Path );
      numberQueues++;
   }

   
   // Display final count.
   Console::WriteLine( "Number of public queues: {0}", numberQueues );
   return;
}


//**************************************************
// Provides an entry point into the application.
//   
// This example uses a cursor to step through the
// message queues and list the public queues on the
// network.
//**************************************************
int main()
{
   
   // Output the count of Lowest priority messages.
   ListPublicQueues();
}

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
        // message queues and list the public queues on the
        // network.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Output the count of Lowest priority messages.
            myNewQueue.ListPublicQueues();
                        
            return;
        }


        //**************************************************
        // Iterates through message queues and examines the
        // path for each queue. Also displays the number of
        // public queues on the network.
        //**************************************************
        
        public void ListPublicQueues()
        {
            // Holds the count of private queues.
            uint numberQueues = 0;
    
            // Get a cursor into the queues on the network.
            MessageQueueEnumerator myQueueEnumerator = 
                MessageQueue.GetMessageQueueEnumerator();

            // Move to the next queue and read its path.
            while(myQueueEnumerator.MoveNext())
            {
                // Increase the count if priority is Lowest.
                Console.WriteLine(myQueueEnumerator.Current.Path);
                numberQueues++;
            }

            // Display final count.
            Console.WriteLine("Number of public queues: " + 
                numberQueues.ToString());
            
            return;
        }
    }
}
Imports System.Messaging



Public Class MyNewQueue


        
        ' Provides an entry point into the application.
        '		 
        ' This example uses a cursor to step through the
        ' message queues and list the public queues on the
        ' network.
        

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Output the count of Lowest priority messages.
            myNewQueue.ListPublicQueues()

            Return

        End Sub


        
        ' Iterates through message queues and examines the
        ' path for each queue. Also displays the number of
        ' public queues on the network.
        

        Public Sub ListPublicQueues()

            ' Holds the count of private queues.
            Dim numberQueues As Int32 = 0

            ' Get a cursor into the queues on the network.
            Dim myQueueEnumerator As MessageQueueEnumerator = _
                MessageQueue.GetMessageQueueEnumerator()

            ' Move to the next queue and read its path.
            While myQueueEnumerator.MoveNext()
                ' Increase the count if the priority is Lowest.
                Console.WriteLine(myQueueEnumerator.Current.Path)
                numberQueues += 1
            End While

            ' Display final count.
            Console.WriteLine(("Number of public queues: " + _
                numberQueues.ToString()))

            Return

        End Sub

End Class

Commenti

Utilizzare MessageQueueEnumerator per l'interazione dinamica con le code sulla rete.Use MessageQueueEnumerator for dynamic interaction with queues on the network. I metodi disponibili tramite MessageQueue la classe possono restituire un MessageQueueEnumerator oggetto contenente un elenco dinamico di code o una matrice che contiene uno snapshot della raccolta della coda nel momento in cui è stato chiamato il metodo specificato.Methods available through the MessageQueue class can return either a MessageQueueEnumerator containing a dynamic list of queues, or an array that contains a snapshot of the queue collection at the time the specified method was called.

Non esiste un ordine definito delle code in una rete.There is no defined ordering of queues in a network. Non sono ordinati, ad esempio, per computer, etichetta, stato pubblico o privato o altri criteri accessibili dall'utente.They are not ordered, for example, by computer, label, public or private status, or other user-accessible criteria. Un MessageQueueEnumerator oggetto è un cursore, inizializzato all'inizio di un elenco dinamico.A MessageQueueEnumerator is a cursor, initialized to the head of a dynamic list. È possibile spostare il cursore sulla prima coda dell'enumerazione MoveNextchiamando.You can move the cursor to the first queue of the enumeration by calling MoveNext. Dopo che l'enumeratore è stato inizializzato, MoveNext è possibile usare per eseguire un'istruzione alla volta nelle code rimanenti.After the enumerator has been initialized, you can use MoveNext to step forward through the remaining queues.

Non è possibile eseguire l'istruzione precedente con un MessageQueueEnumeratoroggetto.It is not possible to step backward with a MessageQueueEnumerator. Un cursore consente lo spostamento in futuro solo tramite l'enumerazione Queue.A cursor only allows forward movement through the queue enumeration. Tuttavia, è possibile chiamare Reset per reimpostare l'enumerazione e inserire nuovamente il cursore all'inizio dell'elenco.However, you can call Reset to reset the enumeration and put the cursor at the beginning of the list again. Poiché l'enumeratore è dinamico, l'enumeratore può accedere a una coda aggiunta oltre la posizione corrente del cursore.Because the enumerator is dynamic, a queue that is appended beyond the cursor's current position can be accessed by the enumerator. Non è possibile accedere A una coda inserita prima della posizione corrente del cursore senza prima chiamare Reset.A queue that is inserted before the cursor's current position cannot be accessed without first calling Reset.

Proprietà

Current

Ottiene la MessageQueue corrente dell'enumerazione.Gets the current MessageQueue of the enumeration.

LocatorHandle

Ottiene l'handle nativo di Accodamento messaggi utilizzato per individuare le code in una rete.Gets the native Message Queuing handle used to locate queues in a network.

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 MessageQueueEnumerator.Releases all resources used by the MessageQueueEnumerator.

Dispose(Boolean)

Rilascia le risorse non gestite usate da MessageQueueEnumerator e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the MessageQueueEnumerator 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 contenute nella coda.Releases the resources held by the queue.

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 alla coda successiva dell'enumerazione, se ve n'è una disponibile.Advances the enumerator to the next queue of the enumeration, if one is currently available.

Reset()

Reimposta il cursore, in modo che punti all'inizio dell'enumerazione.Resets the cursor, so it points to the beginning of the enumeration.

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

Ottiene la MessageQueue corrente dell'enumerazione.Gets the current MessageQueue of the enumeration.

Si applica a

Vedi anche