Les interfaces IEnumerable et IEnumerator
Pour commencer à examiner le processus de mise en œuvre des interfaces .NET existantes, examinons d'abord le rôle de IEnumerable et IEnumerator. Rappelez-vous que C # prend en charge un mot-clé nommé foreach qui vous permet d'itérer sur le contenu de tout type de tableau:
// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
Console.WriteLine(i);
}
Bien qu'il puisse sembler que seuls les types de tableau peuvent utiliser cette construction, la vérité est que tout type prenant en charge une méthode nommée GetEnumerator () peut être évalué par la construction foreach. Pour illustrer, suivez-moi!
Supposons que nous ayons une classe Garage:
// Garage contains a set of Car objects.
public class Garage
{
private Car[] carArray = new Car[4];
// Fill with some Car objects upon startup.
public Garage()
{
carArray[0] = new Car("Rusty", 30);
carArray[1] = new Car("Clunker", 55);
carArray[2] = new Car("Zippy", 30);
carArray[3] = new Car("Fred", 30);
}
}
Idéalement, il serait pratique d'itérer sur les sous-éléments de l'objet Garage à l'aide de la construction foreach, tout comme un tableau de valeurs de données:
// This seems reasonable ...
public class Program
{
static void Main(string[] args)
{
Console.WriteLine("***** Fun with IEnumerable / IEnumerator *****\n");
Garage carLot = new Garage();
// Hand over each car in the collection?
foreach (Car c in carLot)
{
Console.WriteLine("{0} is going {1} MPH",
c.PetName, c.CurrentSpeed);
}
Console.ReadLine();
}
}
Malheureusement, le compilateur vous informe que la classe Garage n'implémente pas une méthode nommée GetEnumerator (). Cette méthode est formalisée par l'interface IEnumerable, qui se cache dans l'espace de noms System.Collections. Les classes ou les structures qui prennent en charge ce comportement annoncent qu'elles sont capables d'exposer des sous-éléments contenus à l'appelant (dans cet exemple, le mot-clé foreach lui-même). Voici la définition de cette interface .NET standard:
// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
Comme vous pouvez le voir, la méthode GetEnumerator () renvoie une référence à une autre interface nommée System.Collections.IEnumerator. Cette interface fournit l'infrastructure permettant à l'appelant de parcourir les objets internes contenus par le conteneur compatible IEnumerable:
// This interface allows the caller to
// obtain a container's subitems.
public interface IEnumerator
{
bool MoveNext (); // Advance the internal position of the cursor.
object Current { get;} // Get the current item (read-only property).
void Reset (); // Reset the cursor before the first member.
}
Si vous souhaitez mettre à jour le type Garage pour prendre en charge ces interfaces, vous pouvez prendre le long chemin et implémenter chaque méthode manuellement. Bien que vous soyez certainement libre de fournir des versions personnalisées de GetEnumerator (), MoveNext (), Current et Reset (), il existe un moyen plus simple. Comme le type System.Array (ainsi que de nombreuses autres classes de collection) implémente déjà IEnumerable et IEnumerator, vous pouvez simplement déléguer la demande à System.Array comme suit:
using System.Collections;
...
public class Garage : IEnumerable
{
// System.Array already implements IEnumerator!
private Car[] carArray = new Car[4];
public Garage()
{
carArray[0] = new Car("FeeFee", 200);
carArray[1] = new Car("Clunker", 90);
carArray[2] = new Car("Zippy", 30);
carArray[3] = new Car("Fred", 30);
}
public IEnumerator GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
}
Après avoir mis à jour votre type de garage, vous pouvez utiliser le type en toute sécurité dans la construction C # foreach. De plus, étant donné que la méthode GetEnumerator () a été définie publiquement, l'utilisateur de l'objet peut également interagir avec le type IEnumerator:
// Manually work with IEnumerator.
IEnumerator i = carLot.GetEnumerator();
i.MoveNext();
Car myCar = (Car)i.Current;
Console.WriteLine("{0} is going {1} MPH", myCar.PetName, myCar.CurrentSpeed);
Cependant, si vous préférez masquer la fonctionnalité de IEnumerable au niveau de l'objet, utilisez simplement l'implémentation d'interface explicite:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
Ce faisant, l'utilisateur de l'objet occasionnel ne trouvera pas la méthode GetEnumerator () de Garage, tandis que la construction foreach obtiendra l'interface en arrière-plan si nécessaire.
Adapté de Pro C # 5.0 et du .NET 4.5 Framework
