As interfaces IEnumerable e IEnumerator
Para começar a examinar o processo de implementação de interfaces .NET existentes, vejamos primeiro a função de IEnumerable e IEnumerator. Lembre-se de que o C # oferece suporte a uma palavra-chave denominada foreach que permite iterar sobre o conteúdo de qualquer tipo de matriz:
// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
Console.WriteLine(i);
}
Embora possa parecer que apenas os tipos de matriz podem fazer uso dessa construção, a verdade é que qualquer tipo que suporte um método chamado GetEnumerator () pode ser avaliado pela construção foreach. Para ilustrar, siga-me!
Suponha que tenhamos uma 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, seria conveniente iterar nos subitens do objeto Garage usando a construção foreach, assim como uma matriz de valores de dados:
// 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();
}
}
Infelizmente, o compilador informa que a classe Garage não implementa um método chamado GetEnumerator (). Esse método é formalizado pela interface IEnumerable, que se encontra à espreita no espaço de nomes System.Collections. Classes ou estruturas que suportam esse comportamento anunciam que podem expor subitens contidos ao chamador (neste exemplo, a própria palavra-chave foreach). Aqui está a definição dessa interface .NET padrão:
// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
Como você pode ver, o método GetEnumerator () retorna uma referência para outra interface chamada System.Collections.IEnumerator. Essa interface fornece a infraestrutura para permitir que o chamador atravesse os objetos internos contidos no contêiner compatível com 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 você deseja atualizar o tipo de Garagem para suportar essas interfaces, pode seguir o longo caminho e implementar cada método manualmente. Embora você tenha a liberdade de fornecer versões personalizadas de GetEnumerator (), MoveNext (), Current e Reset (), existe uma maneira mais simples. Como o tipo System.Array (assim como muitas outras classes de coleção) já implementa IEnumerable e IEnumerator, você pode simplesmente delegar a solicitação ao System.Array da seguinte maneira:
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();
}
}
Depois de atualizar seu tipo de Garagem, você pode usá-lo com segurança na construção C # foreach. Além disso, como o método GetEnumerator () foi definido publicamente, o usuário do objeto também pode interagir com o 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);
No entanto, se você preferir ocultar a funcionalidade de IEnumerable do nível do objeto, basta usar a implementação explícita da interface:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
Ao fazer isso, o usuário do objeto casual não encontrará o método GetEnumerator () do Garage, enquanto a construção foreach obterá a interface em segundo plano quando necessário.
Adaptado do Pro C # 5.0 e do .NET 4.5 Framework
