Iteradores
Aprovechando las ventajas proporcionadas por los genéricos, en la BCL del .NET 2.0 se ha optimizado la implementación de las colecciones introduciendo en un nuevo espacio de nombres System.Collections.Generic dos nuevas interfaces llamadas IEnumerable<T> e IEnumerator<T> que las colecciones podrán implementar para conseguir que el acceso a las colecciones sea mucho más eficiente que con las viejas IEnumerable e IEnumerator al evitarse el boxing/unboxing o downcasting/upcasting que el tipo de retorno object de la propiedad Current de IEnumerator implicaba. Además, en ellas se ha optimizado el diseño eliminando el tan poco utilizado método Reset() y haciéndoles implementar en su lugar la estandarizada interfaz IDisposable. En resumen, están definidas como sigue:
public interface IEnumerable<T>
{
IEnumerator<T> GetEnumerator();
}
public interface IEnumerator<T>: IDisposable
{
T Current { get; }
bool MoveNext();
}
|
Nótese que en realidad C# 1.0 ya proporcionaba a través del patrón de colección un mecanismo con que implementar colecciones fuertemente tipadas. Sin embargo, era algo específico de este lenguaje, oculto y desconocido para muchos programadores y no completamente soportado por otros lenguajes .NET (por ejemplo, Visual Basic.NET y su sentencia For Each) Por el contrario, estas nuevas interfaces genéricas proporcionan una solución más compatible y mejor formulada.
C# 2.0 proporciona además un nuevo mecanismo con el que es resultará mucho sencillo crear colecciones que implementando directamente estas interfaces: los iteradores. Son métodos que para generar objetos que implementen todas estas interfaces se apoyan en una nueva sentencia yield. Han de tener como tipo de retorno IEnumerable, IEnumerator, IEnumerable<T> e IEnumerator<T>, y su cuerpo indicarán los valores a recorrer con sentencias yield return <valor>; en las que si se el tipo de retorno del iterador es genérico, <valor> deberá ser de tipo T. Asimismo, también se marcar el fin de la enumeración y forzar a que MoveNext() siempre devuelva false mediante sentencias yield break;.
A partir de la definición de un iterador, el compilador anidará dentro de la clase en que éste se definió una clase privada que implementará la interfaz de su tipo de retorno. El código del iterador no se ejecutará al llamarle, sino en cada llamada realizada al método MoveNext() del objeto que devuelve, y sólo hasta llegarse a algún yield return. Luego la ejecución se suspenderá hasta la siguiente llamada a MoveNext(), que la reanudará por donde se quedó. Por tanto, sucesivas llamadas a MoveNext() irán devolviendo los valores indicados por los yield return en el mismo orden en que se éstos se ejecuten. Así, en:
using System;
using System.Collections;
class PruebaIteradores
{
public IEnumerator GetEnumerator()
{
yield return 1;
yield return "Hola";
}
public IEnumerable AlRevés
{
get
{
yield return "Hola";
yield return 1;
}
}
static void Main()
{
PruebaIteradores objeto = new PruebaIteradores();
foreach(object valor in objeto)
Console.WriteLine(valor);
foreach(object x in objeto.AlRevés)
Console.WriteLine(x);
}
}
|
La clase PruebaIteradores tendrán un método GetEnumerator() que devolverá un objeto IEnumerator generado en base a las instrucciones yield que retornará como primer elemento un 1 y como segundo la cadena "Hola", por lo que podrá ser recorrida a través de la instrucción foreach. Del mismo modo, su propiedad AlRevés devolverá un objeto que también dispone de dicho método y por tanto también podrá recorrese a través de dicha sentencia, aunque en este caso hace el recorrido al revés. Por tanto, su salida será:
Nótese que aunque los iteradores se puedan usar para definir métodos que devuelvan tanto objetos IEnumerable como IEnumerator, ello no significa que dichos tipos sean intercambiables. Es decir, si en el ejemplo anterior hubiésemos definido la propiedad AlRevés como de tipo IEnumerator, el código no compilaría en tanto que lo que foreach espera es un objeto que implemente IEnumerable, y no un IEnumerator.
En realidad, si el tipo de retorno del iterador es IEnumerator o IEnumerator<T>, la clase interna que se generará implementará tanto la versión genérica de esta interfaz como la que no lo es. Lo mismo ocurre para el caso de IEnumerable e IEnumerable<T>, en el que además, el compilador opcionalmente (el de C# de Microsoft sí lo hace) también podrá implementar las interfaces IEnumerator e IEnumerator<T>. Sin embargo, implementar las interfaces IEnumerator no implica que se implementen las IEnumerable, y de ahí el problema descrito en el párrafo anterior.
Por otro lado, hay que señalar que en el código que se puede incluir dentro de los iteradores existen algunas limitaciones destinadas a evitar rupturas descontroladas de la iteración: no se permiten sentencias return, ni código inseguro ni parámetros por referencia, y las sentencias yield no se puede usar dentro de bloques try, catch o finally.
Internamente, a partir de la definición del iterador el compilador generará una clase interna que implementará la interfaz del tipo de retorno de éste y sustituirá el código del miembro de la colección donde se define el iterador por una instanciación de dicha clase a la que le pasará como parámetro el propio objeto colección a recorrer (this) En ella, el código del iterador se transformará en una implementación del MoveNext() de IEnumerator basada en un algoritmo de máquina de estado, y la posible limpieza de los recursos consumido por la misma se hará en el Dispose() O sea, se generará algo como:
public class <colección>:<interfaz>
{
public virtual <interfaz> GetEnumerator()
{
return GetEnumerator$<númeroAleatorioÚnico>__IEnumeratorImpl impl =
new GetEnumerator$<númeroAleatorioÚnico>__IEnumeratorImpl(this);
}
class GetEnumerator$<númeroAleatorioÚnico>__IEnumeratorImpl:<interfaz>
{
public <colección> @this;
<tipoElementosColección> $_current;
string <interfaz>.Current { get { return $_current; } }
bool <interfaz>.MoveNext()
{
// Implementación de la máquina de estados
}
void IDisposable.Dispose()
{
// Posible limpieza de la máquina de estados
}
}
}
|
Nótese que para cada foreach se generará un nuevo objeto de la clase interna, por lo que el estado de estos iteradores automáticamente generados no se comparte entre foreachs y por tanto el antiguo método Reset() de IEnumerator se vuelve innecesario. Es más, si la interfaz de retorno del iterador fuese IEnumerator, la implementación realizada por el compilador en la clase interna para el obsoleto método de la misma Reset() lanzará una NotSupportedException ante cualquier llamada que explícitamente se le realice. No obstante, hay que tener cuidado con esto pues puede implicar la creación de numerosos objetos en implementaciones recursivas como la siguiente, en la que se aprovechan los iteradores para simplificar la implementación de los recorridos sobre un árbol binario:
using System.Collections.Generic;
public class Nodo<T>
{
public Nodo<T> Izquierdo, Derecho;
public T Valor;
}
public class ÁrbolBinario<T>
{
Nodo<T> raíz;
public IEnumerable<T> Inorden{get{return recorrerEnInorden(this.raíz); } }
IEnumerable<T> recorrerEnInorden(Nodo<T> nodo)
{
Nodo<T> nodoIzquierdo = nodo.Izquierdo;
if (nodoIzquierdo!=null)
foreach(T valor in recorrerEnInorden(nodoIzquierdo))
yield return valor;
yield return raíz.Valor;
Nodo<T> nodoDerecho= nodo.Derecho;
if (nodoDerecho!=null)
foreach(T valor in recorrerEnInorden(nodoDerecho))
yield return valor;
}
// Implementación de recorridos en Preorden y PostOrden y demás miembros
}
|