Le interfacce IEnumerable e IEnumerator
Per iniziare a esaminare il processo di implementazione delle interfacce .NET esistenti, esaminiamo innanzitutto il ruolo di IEnumerable e IEnumerator. Ricorda che C # supporta una parola chiave denominata foreach che ti consente di scorrere i contenuti di qualsiasi tipo di array:
// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
Console.WriteLine(i);
}
Sebbene possa sembrare che solo i tipi di array possano utilizzare questo costrutto, la verità è che qualsiasi tipo che supporti un metodo chiamato GetEnumerator () può essere valutato dal costrutto foreach. Per illustrare, seguimi!
Supponiamo di avere una 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);
}
}
Idealmente, sarebbe conveniente scorrere le voci secondarie dell'oggetto Garage usando il costrutto foreach, proprio come una matrice di valori di dati:
// 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();
}
}
Purtroppo, il compilatore ti informa che la classe Garage non implementa un metodo chiamato GetEnumerator (). Questo metodo è formalizzato dall'interfaccia IEnumerable, che si trova in agguato nello spazio dei nomi System.Collections. Le classi o le strutture che supportano questo comportamento pubblicizzano che sono in grado di esporre al chiamante elementi secondari contenuti (in questo esempio, la parola chiave foreach stessa). Ecco la definizione di questa interfaccia .NET standard:
// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
Come puoi vedere, il metodo GetEnumerator () restituisce un riferimento a un'altra interfaccia denominata System.Collections.IEnumerator. Questa interfaccia fornisce l'infrastruttura per consentire al chiamante di attraversare gli oggetti interni contenuti nel contenitore compatibile con 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.
}
Se desideri aggiornare il tipo di Garage per supportare queste interfacce, potresti prendere la strada lunga e implementare manualmente ogni metodo. Sebbene tu sia certamente libero di fornire versioni personalizzate di GetEnumerator (), MoveNext (), Current e Reset (), esiste un modo più semplice. Poiché il tipo System.Array (così come molte altre classi di raccolta) implementa già IEnumerable e IEnumerator, puoi semplicemente delegare la richiesta a System.Array come segue:
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();
}
}
Dopo aver aggiornato il tipo di Garage, puoi tranquillamente utilizzare il tipo all'interno del costrutto foreach di C #. Inoltre, dato che il metodo GetEnumerator () è stato definito pubblicamente, l'utente oggetto potrebbe anche interagire con il tipo 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);
Tuttavia, se si preferisce nascondere la funzionalità di IEnumerable a livello di oggetto, utilizzare semplicemente l'implementazione esplicita dell'interfaccia:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
In questo modo, l'utente dell'oggetto casuale non troverà il metodo GetEnumerator () di Garage, mentre il costrutto foreach otterrà l'interfaccia in background quando necessario.
Adattato da Pro C # 5.0 e .NET 4.5 Framework
