Cette documentation est archivée et n’est pas conservée.

MessageEnumerator, classe

Mise à jour : novembre 2007

Fournit un curseur avant uniquement pour l'énumération de messages dans une file d'attente.

Espace de noms :  System.Messaging
Assembly :  System.Messaging (dans System.Messaging.dll)

public class MessageEnumerator : MarshalByRefObject, 
	IEnumerator, IDisposable
public class MessageEnumerator extends MarshalByRefObject implements IEnumerator, 
	IDisposable
public class MessageEnumerator extends MarshalByRefObject implements IEnumerator, IDisposable

Utilisez MessageEnumerator pour l'interaction dynamique avec les messages dans une file d'attente. Les méthodes disponibles par l'intermédiaire de la classe MessageQueue peuvent retourner MessageEnumerator pointant vers une liste dynamique de messages dans la file d'attente ou un tableau qui contient une copie d'un instantané donné de la file d'attente au moment où la méthode spécifiée a été appelée.

Contrairement à un instantané statique, un énumérateur vous permet de modifier la collection. À l'aide de MessageEnumerator, vous pouvez supprimer des messages de la file d'attente et la modification sera immédiatement réfléchie dans la file d'attente.

Un énumérateur ne supprime pas les messages de la file d'attente lorsqu'il l'interroge. Il retourne des informations sur le message à la position actuelle du curseur, mais laisse le message dans la file d'attente.

MessageEnumerator est un curseur, initialisé en tête d'une liste dynamique. L'ordre de la liste est le même que l'ordre des messages dans la file d'attente, en fonction de la priorité des messages. Vous pouvez déplacer le curseur vers le premier message de la file d'attente en appelant MoveNext. Une fois l'énumérateur initialisé, vous pouvez utiliser MoveNext pour parcourir les messages restants. Vous pouvez spécifier s'il faut attendre qu'un message soit disponible en passant un délai d'attente dans la méthode MoveNext.

Étant donné que l'énumérateur est dynamique, un message ajouté après la position actuelle du curseur (par exemple, en raison d'une priorité faible) est accessible grâce à l'énumérateur. Un message inséré avant la position actuelle du curseur n'est pas accessible. Il n'est pas possible de reculer avec MessageEnumerator. Un curseur ne permet qu'un mouvement de défilement en avant. La méthode Reset vous permet de replacer le curseur au début de la file d'attente.

Les instances de MessageEnumerator pour une file d'attente donnée fonctionnent indépendamment. Vous pouvez créer deux instances MessageEnumerator qui s'appliquent à la même file d'attente. Les modifications apportées par MessageEnumerator aux messages de la file d'attente seront immédiatement réfléchies dans un second énumérateur si ce dernier est positionné avant le premier. Cependant, si deux énumérateurs ont la même position et que l'un d'entre eux supprime le message au niveau de cette position, une exception est levée si l'autre énumérateur tente d'obtenir la valeur de la propriété Current sur le message qui vient d'être supprimé.

Remarque :

Si vous créez une instance de MessageQueue avec MessageQueue.DenySharedReceive ayant la valeur true, aucune autre application ne peut modifier les messages dans votre énumérateur pendant que vous êtes connecté à la file d'attente.

L'exemple suivant obtient une liste dynamique des messages d'une file d'attente et compte tous les messages dont la propriété Priority a la valeur MessagePriority.Lowest.

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;
		}
	}
}


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


System.Object
  System.MarshalByRefObject
    System.Messaging.MessageEnumerator

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professionnel Édition x64, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile pour Smartphone, Windows Mobile pour Pocket PC

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

.NET Framework

Pris en charge dans : 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Pris en charge dans : 3.5, 2.0
Afficher: