MessageQueueEnumerator Klasse

Definition

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
MessageQueueEnumerator
Implementiert

Beispiele

Im folgenden Codebeispiel werden alle Nachrichtenwarteschlangen im Netzwerk durchlaufen und der Pfad für jede Warteschlange untersucht. 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, öffentlichem oder privatem Status oder anderen kriterien sortiert, auf die der Benutzer zugegriffen werden kann. Ein MessageQueueEnumerator ist ein Cursor, der am 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 MessageQueueEnumeratorzurückzutreten. Ein Cursor lässt nur eine Vorwärtsbewegung durch die Warteschlangenenumeration 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 der Enumerator auf eine Warteschlange zugreifen, 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 ohne den ersten Aufruf von Reset zugegriffen werden.

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:

Weitere Informationen