Iteradores (C# y Visual Basic)
Un iterador se puede utilizar para examinar colecciones, como las listas y las matrices.
Un método iterador o un descriptor de acceso get realiza una iteración personalizada en una colección. Un método iterador utiliza el fragmento Yield (Visual Basic) o yield return (C#) para devolver cada elemento de uno en uno. Cuando se alcanza un fragmento Yield o yield return, se recuerda la ubicación actual en el código. La ejecución se reinicia desde esa ubicación la próxima vez que se llama a la función del iterador.
Utiliza un iterador de código de cliente mediante una instrucción For Each… Next (Visual Basic) o de foreach (C#) o una consulta LINQ.
En el ejemplo siguiente, la primera iteración del bucle de For Each o de foreach hace que continúe la ejecución del método de iterador de SomeNumbers hasta primer Yield o se alcanza la instrucción de yield return. Esta iteración devuelve un valor de 3, y la ubicación actual del método de iterador se conserva. En la siguiente iteración del bucle, la ejecución en el método de iterador continúa de donde se quedó, de nuevo deteniéndose cuando llega a una instrucción de Yield o de yield return. Esta iteración devuelve un valor de 5, y la ubicación actual del método de iterador se conserva de nuevo. El bucle se completa cuando finaliza el método de iterador se alcance.
Sub Main()
For Each number As Integer In SomeNumbers()
Console.Write(number & " ")
Next
' Output: 3 5 8
Console.ReadKey()
End Sub
Private Iterator Function SomeNumbers() As System.Collections.IEnumerable
Yield 3
Yield 5
Yield 8
End Function
static void Main()
{
foreach (int number in SomeNumbers())
{
Console.Write(number.ToString() + " ");
}
// Output: 3 5 8
Console.ReadKey();
}
public static System.Collections.IEnumerable SomeNumbers()
{
yield return 3;
yield return 5;
yield return 8;
}
El tipo de retorno de un método iterador o del descriptor de acceso get puede ser IEnumerable, IEnumerable, IEnumerator, o IEnumerator.
Se puede utilizar una instrucción Exit Function o Return (Visual Basic) o una instrucción yield break (C#) para finalizar la iteración.
Una función de iterador de Visual Basic o una declaración de descriptor de acceso get incluyen un modificador de Iterator.
Los iteradores se introdujeron en C# en Visual Studio 2005 y fueron introducidos también en Visual Basic en Visual Studio 2012.
En este tema
Iterador simple
Crear una clase Colección
Bloque try en Visual Basic
Métodos anónimos en Visual Basic
Usar iteradores con una lista genérica
Información de sintaxis
Implementación técnica
Uso de iteradores
Iterador simple
El ejemplo siguiente tiene una sola instrucción Yield o yield return que está dentro de un bucle For… Next (Visual Basic) o for (C#). En Main, cada iteración del cuerpo de la instrucción For Each o foreach crea una llamada a la función del iterador, que continúa a la siguiente instrucción Yield o yield return.
Sub Main()
For Each number As Integer In EvenSequence(5, 18)
Console.Write(number & " ")
Next
' Output: 6 8 10 12 14 16 18
Console.ReadKey()
End Sub
Private Iterator Function EvenSequence(
ByVal firstNumber As Integer, ByVal lastNumber As Integer) _
As System.Collections.Generic.IEnumerable(Of Integer)
' Yield even numbers in the range.
For number As Integer = firstNumber To lastNumber
If number Mod 2 = 0 Then
Yield number
End If
Next
End Function
static void Main()
{
foreach (int number in EvenSequence(5, 18))
{
Console.Write(number.ToString() + " ");
}
// Output: 6 8 10 12 14 16 18
Console.ReadKey();
}
public static System.Collections.Generic.IEnumerable<int>
EvenSequence(int firstNumber, int lastNumber)
{
// Yield even numbers in the range.
for (int number = firstNumber; number <= lastNumber; number++)
{
if (number % 2 == 0)
{
yield return number;
}
}
}
Crear una clase Colección
Nota
Para los ejemplos restantes en el tema, incluya declaraciones de Imports (Visual Basic) o directivas using (C#) para los espacios de nombres System.Collections y System.Collections.Generic.
En el ejemplo siguiente, la clase DaysOfTheWeek implementa la interfaz IEnumerable, que requiere un método GetEnumerator. El compilador llama implícitamente al método GetEnumerator, que devuelve un IEnumerator.
El método GetEnumerator devuelve cada cadena una por una, utilizando la instrucción Yield o yield return. En el código Visual Basic, un modificador Iterator está en la declaración de función.
Sub Main()
Dim days As New DaysOfTheWeek()
For Each day As String In days
Console.Write(day & " ")
Next
' Output: Sun Mon Tue Wed Thu Fri Sat
Console.ReadKey()
End Sub
Private Class DaysOfTheWeek
Implements IEnumerable
Public days =
New String() {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}
Public Iterator Function GetEnumerator() As IEnumerator _
Implements IEnumerable.GetEnumerator
' Yield each day of the week.
For i As Integer = 0 To days.Length - 1
Yield days(i)
Next
End Function
End Class
static void Main()
{
DaysOfTheWeek days = new DaysOfTheWeek();
foreach (string day in days)
{
Console.Write(day + " ");
}
// Output: Sun Mon Tue Wed Thu Fri Sat
Console.ReadKey();
}
public class DaysOfTheWeek : IEnumerable
{
private string[] days = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
public IEnumerator GetEnumerator()
{
for (int index = 0; index < days.Length; index++)
{
// Yield each day of the week.
yield return days[index];
}
}
}
El ejemplo siguiente crea una clase Zoo que contiene una colección de animales.
La instrucción For Each o foreach que hace referencia a la instancia de clase (theZoo) llama implícitamente al método GetEnumerator. Las instrucciones For Each o foreach que hacen referencia a las propiedades Birds y Mammals utilizan el método iterador nombrado AnimalsForType.
Sub Main()
Dim theZoo As New Zoo()
theZoo.AddMammal("Whale")
theZoo.AddMammal("Rhinoceros")
theZoo.AddBird("Penguin")
theZoo.AddBird("Warbler")
For Each name As String In theZoo
Console.Write(name & " ")
Next
Console.WriteLine()
' Output: Whale Rhinoceros Penguin Warbler
For Each name As String In theZoo.Birds
Console.Write(name & " ")
Next
Console.WriteLine()
' Output: Penguin Warbler
For Each name As String In theZoo.Mammals
Console.Write(name & " ")
Next
Console.WriteLine()
' Output: Whale Rhinoceros
Console.ReadKey()
End Sub
Public Class Zoo
Implements IEnumerable
' Private members.
Private animals As New List(Of Animal)
' Public methods.
Public Sub AddMammal(ByVal name As String)
animals.Add(New Animal With {.Name = name, .Type = Animal.TypeEnum.Mammal})
End Sub
Public Sub AddBird(ByVal name As String)
animals.Add(New Animal With {.Name = name, .Type = Animal.TypeEnum.Bird})
End Sub
Public Iterator Function GetEnumerator() As IEnumerator _
Implements IEnumerable.GetEnumerator
For Each theAnimal As Animal In animals
Yield theAnimal.Name
Next
End Function
' Public members.
Public ReadOnly Property Mammals As IEnumerable
Get
Return AnimalsForType(Animal.TypeEnum.Mammal)
End Get
End Property
Public ReadOnly Property Birds As IEnumerable
Get
Return AnimalsForType(Animal.TypeEnum.Bird)
End Get
End Property
' Private methods.
Private Iterator Function AnimalsForType( _
ByVal type As Animal.TypeEnum) As IEnumerable
For Each theAnimal As Animal In animals
If (theAnimal.Type = type) Then
Yield theAnimal.Name
End If
Next
End Function
' Private class.
Private Class Animal
Public Enum TypeEnum
Bird
Mammal
End Enum
Public Property Name As String
Public Property Type As TypeEnum
End Class
End Class
static void Main()
{
Zoo theZoo = new Zoo();
theZoo.AddMammal("Whale");
theZoo.AddMammal("Rhinoceros");
theZoo.AddBird("Penguin");
theZoo.AddBird("Warbler");
foreach (string name in theZoo)
{
Console.Write(name + " ");
}
Console.WriteLine();
// Output: Whale Rhinoceros Penguin Warbler
foreach (string name in theZoo.Birds)
{
Console.Write(name + " ");
}
Console.WriteLine();
// Output: Penguin Warbler
foreach (string name in theZoo.Mammals)
{
Console.Write(name + " ");
}
Console.WriteLine();
// Output: Whale Rhinoceros
Console.ReadKey();
}
public class Zoo : IEnumerable
{
// Private members.
private List<Animal> animals = new List<Animal>();
// Public methods.
public void AddMammal(string name)
{
animals.Add(new Animal { Name = name, Type = Animal.TypeEnum.Mammal });
}
public void AddBird(string name)
{
animals.Add(new Animal { Name = name, Type = Animal.TypeEnum.Bird });
}
public IEnumerator GetEnumerator()
{
foreach (Animal theAnimal in animals)
{
yield return theAnimal.Name;
}
}
// Public members.
public IEnumerable Mammals
{
get { return AnimalsForType(Animal.TypeEnum.Mammal); }
}
public IEnumerable Birds
{
get { return AnimalsForType(Animal.TypeEnum.Bird); }
}
// Private methods.
private IEnumerable AnimalsForType(Animal.TypeEnum type)
{
foreach (Animal theAnimal in animals)
{
if (theAnimal.Type == type)
{
yield return theAnimal.Name;
}
}
}
// Private class.
private class Animal
{
public enum TypeEnum { Bird, Mammal }
public string Name { get; set; }
public TypeEnum Type { get; set; }
}
}
Bloque try en Visual Basic
Visual Basic permite un fragmento Yield en el bloque Try de un Instrucción Try...Catch...Finally (Visual Basic). Un bloque Try que tenga una instrucción Yield puede tener bloques Catch y un bloque Finally.
.gif "Nota para C#") Nota para C# |
|---|
C# permite una instrucción yield return en el bloque try de un fragmento try-finally.Un bloque try que tenga una instrucción yield return no puede tener bloques catch. |
El siguiente ejemplo Visual Basic incluye Try, Catch y bloques Finally en una función iteradora. El bloque Finally en la función iteradora se ejecuta antes de que la iteración For Each termine.
Sub Main()
For Each number As Integer In Test()
Console.WriteLine(number)
Next
Console.WriteLine("For Each is done.")
' Output:
' 3
' 4
' Something happened. Yields are done.
' Finally is called.
' For Each is done.
Console.ReadKey()
End Sub
Private Iterator Function Test() As IEnumerable(Of Integer)
Try
Yield 3
Yield 4
Throw New Exception("Something happened. Yields are done.")
Yield 5
Yield 6
Catch ex As Exception
Console.WriteLine(ex.Message)
Finally
Console.WriteLine("Finally is called.")
End Try
End Function
Una instrucción Yield no puede estar dentro de un bloque Catch o Finally.
Si el cuerpo de la instrucción For Each (en lugar del método iterador) produce una excepción, no se ejecuta el bloque Catch en la función del iterador, pero sí se ejecuta el bloque Finally en dicha función del iterador. Un bloque Catch dentro de una función iteradora detecta las excepciones que se producen dentro de la función iteradora.
Métodos anónimos en Visual Basic
En Visual Basic (pero no en C#), una función anónima puede ser una función de iterador. Esto se ilustra en el siguiente ejemplo:
Dim iterateSequence = Iterator Function() _
As IEnumerable(Of Integer)
Yield 1
Yield 2
End Function
For Each number As Integer In iterateSequence()
Console.Write(number & " ")
Next
' Output: 1 2
Console.ReadKey()
El siguiente ejemplo Visual Basic tiene un método no iterador que valida los argumentos. El método devuelve el resultado de un iterador anónimo que describe los elementos de la colección.
Sub Main()
For Each number As Integer In GetSequence(5, 10)
Console.Write(number & " ")
Next
' Output: 5 6 7 8 9 10
Console.ReadKey()
End Sub
Public Function GetSequence(ByVal low As Integer, ByVal high As Integer) _
As IEnumerable
' Validate the arguments.
If low < 1 Then
Throw New ArgumentException("low is too low")
End If
If high > 140 Then
Throw New ArgumentException("high is too high")
End If
' Return an anonymous iterator function.
Dim iterateSequence = Iterator Function() As IEnumerable
For index = low To high
Yield index
Next
End Function
Return iterateSequence()
End Function
Si en vez de ello, la validación está dentro de la función del iterador, la validación no se puede ejecutar hasta el inicio de la primera iteración del cuerpo de la instrucción For Each.
Usar iteradores con una lista genérica
En el ejemplo siguiente, la clase genérica Stack(Of T) implementa la interfaz genérica IEnumerable. El método Push asigna valores a una matriz de tipo T. El método GetEnumerator devuelve los valores de la matriz utilizando la instrucción Yield o yield return.
Además del método genérico GetEnumerator, el método no genérico GetEnumerator también se debe implementar. Esto es porque IEnumerable hereda de IEnumerable. La implementación no genérica pasa a la implementación genérica.
El ejemplo utiliza iteradores nombrados para admitir distintas maneras de iterar sobre la misma colección de datos. Estos iteradores nombrados son las propiedades TopToBottom y BottomToTop y el método TopN.
La propiedad BottomToTop utiliza un iterador en un descriptor de acceso get. En el código Visual Basic, la declaración de propiedad incluye la palabra clave Iterator.
Sub Main()
Dim theStack As New Stack(Of Integer)
' Add items to the stack.
For number As Integer = 0 To 9
theStack.Push(number)
Next
' Retrieve items from the stack.
' For Each is allowed because theStack implements
' IEnumerable(Of Integer).
For Each number As Integer In theStack
Console.Write("{0} ", number)
Next
Console.WriteLine()
' Output: 9 8 7 6 5 4 3 2 1 0
' For Each is allowed, because theStack.TopToBottom
' returns IEnumerable(Of Integer).
For Each number As Integer In theStack.TopToBottom
Console.Write("{0} ", number)
Next
Console.WriteLine()
' Output: 9 8 7 6 5 4 3 2 1 0
For Each number As Integer In theStack.BottomToTop
Console.Write("{0} ", number)
Next
Console.WriteLine()
' Output: 0 1 2 3 4 5 6 7 8 9
For Each number As Integer In theStack.TopN(7)
Console.Write("{0} ", number)
Next
Console.WriteLine()
' Output: 9 8 7 6 5 4 3
Console.ReadKey()
End Sub
Public Class Stack(Of T)
Implements IEnumerable(Of T)
Private values As T() = New T(99) {}
Private top As Integer = 0
Public Sub Push(ByVal t As T)
values(top) = t
top = top + 1
End Sub
Public Function Pop() As T
top = top - 1
Return values(top)
End Function
' This function implements the GetEnumerator method. It allows
' an instance of the class to be used in a For Each statement.
Public Iterator Function GetEnumerator() As IEnumerator(Of T) _
Implements IEnumerable(Of T).GetEnumerator
For index As Integer = top - 1 To 0 Step -1
Yield values(index)
Next
End Function
Public Iterator Function GetEnumerator1() As IEnumerator _
Implements IEnumerable.GetEnumerator
Yield GetEnumerator()
End Function
Public ReadOnly Property TopToBottom() As IEnumerable(Of T)
Get
Return Me
End Get
End Property
Public ReadOnly Iterator Property BottomToTop As IEnumerable(Of T)
Get
For index As Integer = 0 To top - 1
Yield values(index)
Next
End Get
End Property
Public Iterator Function TopN(ByVal itemsFromTop As Integer) _
As IEnumerable(Of T)
' Return less than itemsFromTop if necessary.
Dim startIndex As Integer =
If(itemsFromTop >= top, 0, top - itemsFromTop)
For index As Integer = top - 1 To startIndex Step -1
Yield values(index)
Next
End Function
End Class
static void Main()
{
Stack<int> theStack = new Stack<int>();
// Add items to the stack.
for (int number = 0; number <= 9; number++)
{
theStack.Push(number);
}
// Retrieve items from the stack.
// foreach is allowed because theStack implements
// IEnumerable<int>.
foreach (int number in theStack)
{
Console.Write("{0} ", number);
}
Console.WriteLine();
// Output: 9 8 7 6 5 4 3 2 1 0
// foreach is allowed, because theStack.TopToBottom
// returns IEnumerable(Of Integer).
foreach (int number in theStack.TopToBottom)
{
Console.Write("{0} ", number);
}
Console.WriteLine();
// Output: 9 8 7 6 5 4 3 2 1 0
foreach (int number in theStack.BottomToTop)
{
Console.Write("{0} ", number);
}
Console.WriteLine();
// Output: 0 1 2 3 4 5 6 7 8 9
foreach (int number in theStack.TopN(7))
{
Console.Write("{0} ", number);
}
Console.WriteLine();
// Output: 9 8 7 6 5 4 3
Console.ReadKey();
}
public class Stack<T> : IEnumerable<T>
{
private T[] values = new T[100];
private int top = 0;
public void Push(T t)
{
values[top] = t;
top++;
}
public T Pop()
{
top--;
return values[top];
}
// This method implements the GetEnumerator method. It allows
// an instance of the class to be used in a foreach statement.
public IEnumerator<T> GetEnumerator()
{
for (int index = top - 1; index >= 0; index--)
{
yield return values[index];
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public IEnumerable<T> TopToBottom
{
get { return this; }
}
public IEnumerable<T> BottomToTop
{
get
{
for (int index = 0; index <= top - 1; index++)
{
yield return values[index];
}
}
}
public IEnumerable<T> TopN(int itemsFromTop)
{
// Return less than itemsFromTop if necessary.
int startIndex = itemsFromTop >= top ? 0 : top - itemsFromTop;
for (int index = top - 1; index >= startIndex; index--)
{
yield return values[index];
}
}
}
Información de sintaxis
Un iterador puede aparecer como un método o descriptor de acceso get. Un iterador no puede aparecer en un evento, un constructor de instancia, un constructor estático, o un destructor estático.
Una conversión implícita debe existir partiendo de la expresión en la instrucción Yield (Visual Basic) o yield return (C#) al tipo de valor devuelto por el iterador.
En Visual Basic, un método de iterador no puede tener ningún parámetro ByRef. En C#, un método de iterador no puede tener ningún parámetro ref o out.
En Visual Basic, “Yield” no es una palabra reservada y tiene un significado especial únicamente cuando se usa en un método Iterator o un descriptor de acceso get. En C#, “yield” no es una palabra reservada y tiene un significado especial sólo cuando se utiliza antes de las palabras clave return o break.
Implementación técnica
Aunque un iterador se escribe como un método, el compilador lo traduce en una clase anidada que es, en realidad, una máquina de estados. Esta clase hace un seguimiento de la posición del iterador mientras continúe el bucle For Each...Next o foreach del código cliente.
Para ver lo que el compilador hace, se puede utilizar la herramienta de Ildasm.exe para ver el código de lenguaje intermedio de Microsoft que se genera para un método iterador.
Al crear un iterador para una clase o struct, no se tiene que implementar la interfaz IEnumerator completa. Cuando el compilador detecta el iterador, genera automáticamente los métodos Current, MoveNext, y Dispose de la interfaz IEnumerator o IEnumerator.
En cada iteración sucesiva del bucle For Each…Next o foreach (o de una invocación directa a IEnumerator.MoveNext), el siguiente cuerpo del código del iterador reanuda la ejecución después de la instrucción anterior Yield o yield return. Después, continúa con la siguiente instrucción Yield o yield return hasta que alcance el final del cuerpo del iterador, o hasta que un fragmento Exit Function, Return (Visual Basic) o yield break (C#) se encuentre.
Los iteradores no admiten el método IEnumerator.Reset. Recordemos que para iterar desde el principio, se debe obtener un nuevo iterador.
Para más información, consulte Especificación del lenguaje de Visual Basic o Especificación del lenguaje C#.
Uso de iteradores
Los iteradores permiten mantener la simplicidad de un bucle For Each cuando se necesita utilizar código complejo para rellenar una secuencia de la lista. Esto puede ser útil cuando se desee hacer lo siguiente:
Modificar la secuencia de la lista después de la primera iteración del bucle For Each.
Evitar cargar totalmente una lista grande antes de la primera iteración de un bucle For Each. Un ejemplo es una búsqueda paginada para cargar un lote de filas de la tabla. Otro ejemplo es el método EnumerateFiles, que implementa iteradores dentro de .NET Framework.
Encapsular la construcción de la lista del iterador. En el método iterador, se puede compilar la lista y después devolver cada resultado en un bucle.
Los blogs siguientes de C# proporcionan información adicional sobre el uso de iteradores.
Vea también
Referencia
Instrucción For Each...Next (Visual Basic)
foreach, in (Referencia de C#)
Yield (Instrucción) (Visual Basic)
Utilizar foreach con matrices (Guía de programación de C#)