Nota
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Se puede usar un iterador para recorrer recopilaciones como listas y matrices.
Un método iterador o un descriptor de acceso get realiza una iteración personalizada en una colección. Un método de iterador usa la instrucción yield return para devolver cada elemento de uno en uno. Cuando se alcanza una instrucción 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 llame a la función de iterador.
Para consumir un método iterador desde código de cliente, use una instrucción foreach o una consulta de LINQ.
En el siguiente ejemplo, la primera iteración del foreach bucle provoca que la ejecución avance en el método SomeNumbers iterador hasta que se llegue a la primera instrucción yield return. Esta iteración devuelve un valor de 3 y se conserva la ubicación actual del método iterador. En la siguiente iteración del bucle, la ejecución en el método iterador continúa desde donde se dejó, deteniéndose de nuevo cuando llega a una instrucción yield return. Esta iteración devuelve un valor de 5 y la ubicación actual del método iterador se conserva de nuevo. El bucle se completa cuando se alcanza el final del método iterador.
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 valor devuelto de un método de iterador o descriptor de acceso get puede ser IEnumerable, IEnumerable<T>, IEnumerator, o IEnumerator<T>.
Puede usar una yield break instrucción para finalizar la iteración.
Nota:
En todos los ejemplos de este tema, excepto en el ejemplo de iterador simple, incluya directivas using para los espacios de nombres System.Collections y System.Collections.Generic.
Iterador simple
El ejemplo siguiente tiene una única yield return instrucción que está dentro de un bucle for . En Main, cada iteración del cuerpo de la instrucción foreach crea una llamada a la función de iterador, que continúa a la instrucción yield return siguiente.
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 de colección
En el ejemplo siguiente, la DaysOfTheWeek clase implementa la IEnumerable interfaz , que requiere un GetEnumerator método . El compilador llama implícitamente al GetEnumerator método , que devuelve un IEnumerator.
El GetEnumerator método devuelve cada cadena una a la vez mediante la yield return instrucción .
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];
}
}
}
En el ejemplo siguiente se crea una Zoo clase que contiene una colección de animales.
La foreach instrucción que hace referencia a la instancia de clase (theZoo) llama implícitamente al método GetEnumerator. Las foreach instrucciones que hacen referencia a las propiedades Birds y Mammals emplean el método iterador denominado AnimalsForType.
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; }
}
}
Uso de iteradores con una lista genérica
En el ejemplo siguiente, la Stack<T> clase genérica implementa la IEnumerable<T> interfaz genérica. El Push método asigna valores a una matriz de tipo T. El GetEnumerator método devuelve los valores de matriz mediante la yield return instrucción .
Además del método genérico GetEnumerator , también se debe implementar el método no genérico GetEnumerator . Esto se debe a que IEnumerable<T> hereda de IEnumerable. La implementación no genérica aplaza la implementación genérica.
El ejemplo usa iteradores con nombre para admitir distintas formas de recorrer en iteración la misma colección de datos. Estos iteradores con nombre son las propiedades TopToBottom y BottomToTop, y el método TopN.
La propiedad BottomToTop usa un iterador en un descriptor de acceso get.
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 ocurrir como un método o como un get accesor. Un iterador no se puede usar en un evento, constructor de instancia, constructor estático o finalizador estático.
Debe existir una conversión implícita desde el tipo de expresión en la instrucción yield return al argumento de tipo para el valor IEnumerable<T> devuelto por el iterador.
En C#, un método iterador no puede tener parámetros in, ref o out.
En C#, yield no es una palabra reservada y tiene un significado especial solo cuando se usa antes de una return palabra clave o break .
Implementación técnica
Aunque se escribe un iterador como método, el compilador lo traduce en una clase anidada que es, en efecto, una máquina de estado. Esta clase realiza un seguimiento de la posición del iterador siempre que continúe el foreach bucle en el código de cliente.
Para ver lo que hace el compilador, puede usar la herramienta Ildasm.exe para ver el código de lenguaje intermedio común que se genera para un método iterador.
Al crear un iterador para una clase o estructura, no es necesario implementar toda IEnumerator la interfaz. Cuando el compilador detecta el iterador, genera automáticamente los Currentmétodos , MoveNexty Dispose de la IEnumerator interfaz o IEnumerator<T> .
En cada iteración sucesiva del bucle foreach (o la llamada directa a IEnumerator.MoveNext), el cuerpo de código del iterador siguiente se reanuda después de la instrucción yield return anterior. Después continúa con la siguiente instrucción yield return hasta que se alcanza el final del cuerpo del iterador, o hasta que se encuentra una instrucción yield break.
Los iteradores no admiten el IEnumerator.Reset método . Para volver a recorrer en iteración desde el principio, se debe obtener un nuevo iterador. Una llamada a Reset en el iterador devuelto por un método de iterador inicia una excepción NotSupportedException.
Para obtener más información, consulte especificación del lenguaje C#.
Uso de iteradores
Los iteradores permiten mantener la simplicidad de un foreach bucle cuando se necesita usar código complejo para rellenar una secuencia de lista. Esto puede ser útil cuando desee hacer lo siguiente:
Modifique la secuencia de lista después de la primera
foreachiteración del bucle.Evite cargar completamente una lista grande antes de la primera iteración de un
foreachbucle. Un ejemplo es una búsqueda paginada para cargar un lote de filas de tabla. Otro ejemplo es el EnumerateFiles método , que implementa iteradores en .NET.Encapsular la creación de la lista en el iterador. En el método iterador, puede compilar la lista y, a continuación, generar cada resultado en un bucle.
Consulte también
Colaborar con nosotros en GitHub
El origen de este contenido se puede encontrar en GitHub, donde también puede crear y revisar problemas y solicitudes de incorporación de cambios. Para más información, consulte nuestra guía para colaboradores.
