Las interfaces IEnumerable e IEnumerator
Para comenzar a examinar el proceso de implementación de las interfaces .NET existentes, primero veamos el rol de IEnumerable e IEnumerator. Recuerde que C # admite una palabra clave denominada foreach que le permite iterar sobre el contenido de cualquier tipo de matriz:
// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
Console.WriteLine(i);
}
Si bien puede parecer que solo los tipos de matriz pueden hacer uso de esta construcción, la verdad del asunto es que cualquier tipo que admita un método llamado GetEnumerator () puede ser evaluado por la construcción foreach. Para ilustrar, ¡sígueme!
Supongamos que tenemos una clase de garaje:
// 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, sería conveniente iterar sobre los subelementos del objeto Garage utilizando la construcción foreach, al igual que una matriz de valores de datos:
// 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();
}
}
Lamentablemente, el compilador le informa que la clase Garage no implementa un método llamado GetEnumerator (). Este método está formalizado por la interfaz IEnumerable, que se encuentra al acecho dentro del espacio de nombres System.Collections. Las clases o estructuras que admiten este comportamiento anuncian que pueden exponer subpuntos contenidos al llamante (en este ejemplo, la palabra clave foreach en sí). Aquí está la definición de esta interfaz estándar .NET:
// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
Como puede ver, el método GetEnumerator () devuelve una referencia a otra interfaz llamada System.Collections.IEnumerator. Esta interfaz proporciona la infraestructura para permitir que la persona que llama atraviese los objetos internos contenidos en el contenedor compatible 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.
}
Si desea actualizar el tipo de garaje para admitir estas interfaces, puede tomar el camino largo e implementar cada método manualmente. Si bien puede proporcionar versiones personalizadas de GetEnumerator (), MoveNext (), Current y Reset (), existe una forma más sencilla. Como el tipo System.Array (así como muchas otras clases de colección) ya implementa IEnumerable e IEnumerator, simplemente puede delegar la solicitud al System.Array de la siguiente manera:
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();
}
}
Una vez que haya actualizado su tipo de Garaje, puede usarlo con seguridad dentro de la construcción foreach de C #. Además, dado que el método GetEnumerator () se ha definido públicamente, el usuario del objeto también podría interactuar con el 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);
Sin embargo, si prefiere ocultar la funcionalidad de IEnumerable del nivel de objeto, simplemente utilice la implementación explícita de la interfaz:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
Al hacerlo, el usuario de objetos casuales no encontrará el método GetEnumerator () de Garage, mientras que la construcción foreach obtendrá la interfaz en segundo plano cuando sea necesario.
Adaptado de Pro C # 5.0 y .NET 4.5 Framework
