MessageQueueEnumerator Klasse

Referenz

Definition

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt einen Vorwärtscursor zum Aufzählen der Nachrichten in einer Nachrichtenwarteschlange bereit.

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

Vererbung: Object

MarshalByRefObject
MessageQueueEnumerator

Implementiert: IEnumerator IDisposable

Beispiele

Das folgende Codebeispiel durchläuft alle Nachrichtenwarteschlangen im Netzwerk und untersucht den Pfad für jede Warteschlange. Schließlich wird die Anzahl der öffentlichen Warteschlangen im Netzwerk angezeigt.

#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

Hinweise

Verwenden Sie MessageQueueEnumerator für die dynamische Interaktion mit Warteschlangen im Netzwerk. Methoden, die über die MessageQueue -Klasse verfügbar sind, können entweder eine MessageQueueEnumerator zurückgeben, die eine dynamische Liste von Warteschlangen enthält, oder ein Array, das zum Zeitpunkt des Aufrufs der angegebenen Methode eine Momentaufnahme der Warteschlangenauflistung enthält.

Es gibt keine definierte Reihenfolge von Warteschlangen in einem Netzwerk. Sie werden z. B. nicht nach Computer, Bezeichnung, öffentliche oder private status oder andere kriterien sortiert, die für den Benutzer zugänglich sind. A MessageQueueEnumerator ist ein Cursor, der für den Kopf einer dynamischen Liste initialisiert wird. Sie können den Cursor in die erste Warteschlange der Enumeration verschieben, indem Sie aufrufen MoveNext. Nachdem der Enumerator initialisiert wurde, können Sie verwenden MoveNext , um die verbleibenden Warteschlangen zu durchlaufen.

Es ist nicht möglich, mit einem MessageQueueEnumeratorrückwärts zu treten. Ein Cursor lässt nur Vorwärtsbewegungen durch die Warteschlangenaufzählung zu. Sie können jedoch aufrufen Reset , um die Enumeration zurückzusetzen und den Cursor erneut an den Anfang der Liste zu setzen. Da der Enumerator dynamisch ist, kann vom Enumerator auf eine Warteschlange zugegriffen werden, die über die aktuelle Position des Cursors hinaus angefügt wird. Auf eine Warteschlange, die vor der aktuellen Position des Cursors eingefügt wird, kann nicht zugegriffen werden, ohne zuerst Reset zu aufrufen.

Eigenschaften

Current	Ruft die aktuelle MessageQueue der Enumeration ab.
LocatorHandle	Ruft das systemeigene Handle von Message Queuing ab, das zum Suchen von Warteschlangen in einem Netzwerk verwendet wird.

Methoden

Close()	Gibt die dem Enumerator zugeordneten Ressourcen frei.
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
Dispose()	Gibt alle vom MessageQueueEnumerator verwendeten Ressourcen frei.
Dispose(Boolean)	Gibt die von MessageQueueEnumerator verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
Finalize()	Gibt die von dieser Warteschlange reservierten Ressourcen frei.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
MoveNext()	Setzt den Enumerator auf die nächste Warteschlange der Enumeration, sofern eine Warteschlange verfügbar ist.
Reset()	Setzt den Cursor zurück auf den Anfang der Enumeration.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

IEnumerator.Current

Ruft die aktuelle MessageQueue der Enumeration ab.

Gilt für:

Teilen über