MessageEnumerator-Klasse
Stellt einen Vorwärtscursor zum Durchlaufen der Meldungen in einer Meldungswarteschlange bereit.
Namespace: System.Messaging
Assembly: System.Messaging (in system.messaging.dll)
Syntax
'Declaration
Public Class MessageEnumerator
Inherits MarshalByRefObject
Implements IEnumerator, IDisposable
'Usage
Dim instance As MessageEnumerator
public class MessageEnumerator : MarshalByRefObject, IEnumerator, IDisposable
public ref class MessageEnumerator : public MarshalByRefObject, IEnumerator, IDisposable
public class MessageEnumerator extends MarshalByRefObject implements IEnumerator, IDisposable
public class MessageEnumerator extends MarshalByRefObject implements IEnumerator, IDisposable
Hinweise
Verwenden Sie den MessageEnumerator zur dynamischen Interaktion mit Meldungen in einer Warteschlange. Die von der MessageQueue-Klasse bereitgestellten Methoden geben entweder einen MessageEnumerator zurück, der auf eine dynamische Liste von Meldungen in der Warteschlange zeigt, oder ein Array mit einer Kopie der Warteschlange zum Zeitpunkt des Methodenaufrufs (Snapshot).
Im Gegensatz zu einem statischen Snapshot können Sie mit einem Enumerator die Auflistung verändern. Wenn Sie Meldungen über einen MessageEnumerator aus der Warteschlange entfernen, wird die Änderung unmittelbar in der Warteschlange wirksam.
Beim Abfragen der Warteschlange entfernt ein Enumerator die Meldungen nicht aus der Warteschlange. Er gibt Informationen über die Meldung an der aktuellen Cursorposition zurück, belässt die Meldung aber in der Warteschlange.
Ein MessageEnumerator ist ein Cursor, der beim Initialisieren auf den Anfang einer dynamischen Liste gesetzt wird. Die Reihenfolge der Liste entspricht der Reihenfolge der Meldungen in der Warteschlange entsprechend der Meldungspriorität. Durch einen Aufruf von MoveNext verschieben Sie den Cursor auf die erste Meldung in der Warteschlange. Nach der Initialisierung des Enumerators können Sie mit MoveNext die einzelnen Meldungen durchlaufen. Weiterhin ermöglicht die MoveNext-Methode die Angabe eines Timeouts, um eine Wartezeit für Meldungen festzulegen, die noch nicht verfügbar sind.
Da ein Enumerator dynamisch ist, kann über ihn auf eine Meldung zugegriffen werden, die hinter der aktuellen Position des Cursors angefügt wurde (beispielsweise aufgrund einer niedrigeren Priorität). Auf eine Meldung, die vor der aktuellen Cursorposition eingefügt wurde, kann nicht zugegriffen werden. Es ist nicht möglich, einen MessageEnumerator auf eine Meldung vor der aktuellen Position zu setzen. Ein Cursor kann nur vorwärts bewegt werden. Mit der Reset-Methode können Sie den Cursor auf den Anfang der Warteschlange zurücksetzen.
Verschiedene Instanzen des MessageEnumerator für dieselbe Warteschlage arbeiten unabhängig voneinander. Sie können zwei MessageEnumerator-Instanzen erstellen, die auf dieselbe Warteschlange angewendet werden. Die von einer der MessageEnumerator-Instanzen durchgeführten Änderungen in der Warteschlange wirken sich unmittelbar auf einen anderen Enumerator aus, sofern sich dieser vor dem ersten Enumerator befindet. Wenn zwei Enumeratoren allerdings auf dieselbe Position zeigen und einer von ihnen die Meldung an dieser Position entfernt, wird eine Ausnahme ausgelöst, sobald der zweite Enumerator den Wert der Current-Eigenschaft für die bereits gelöschte Meldung abruft.
Hinweis
Wenn eine Instanz von MessageQueue erstellt und MessageQueue.DenySharedReceive dabei auf true festgelegt wird, kann keine andere Anwendung die Meldungen im Enumerator ändern, während dieser mit der Warteschlange verbunden ist.
Beispiel
Im folgenden Beispiel wird eine dynamische Liste von Meldungen in einer Warteschlange abgerufen, und es werden alle Meldungen gezählt, deren Priority-Eigenschaft auf MessagePriority.Lowest festgelegt ist.
Imports System
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 'Main
' 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 'CountLowestPriority
End Class 'MyNewQueue
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;
}
}
}
#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;
}
package MyProject;
import System.*;
import System.Messaging.*;
/// <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(String[] args)
{
// Create a new instance of the class.
MyNewQueue myNewQueue = new MyNewQueue();
// Output the count of Lowest priority messages.
myNewQueue.CountLowestPriority();
return;
} //main
//**************************************************
// Iterates through messages in a queue and examines
// their priority.
//**************************************************
public void CountLowestPriority()
{
// Holds the count of Lowest priority messages.
long 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.get_MessageReadPropertyFilter().set_Priority(true);
// Move to the next message and examine its priority.
while (myEnumerator.MoveNext()) {
// Increase the count if priority is Lowest.
if (myEnumerator.get_Current().get_Priority().
Equals(MessagePriority.Lowest)) {
numberItems++;
}
}
// Display final count.
Console.WriteLine("Lowest priority messages: "
+ ((Int32)numberItems).ToString());
return;
} //CountLowestPriority
} //MyNewQueue
Vererbungshierarchie
System.Object
System.MarshalByRefObject
System.Messaging.MessageEnumerator
Threadsicherheit
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0
Siehe auch
Referenz
MessageEnumerator-Member
System.Messaging-Namespace
Message-Klasse
MessageQueue.GetMessageEnumerator2