Colecciones (C#)Collections (C#)

Para muchas aplicaciones, puede que desee crear y administrar grupos de objetos relacionados.For many applications, you want to create and manage groups of related objects. Existen dos formas de agrupar objetos: mediante la creación de matrices de objetos y con la creación de colecciones de objetos.There are two ways to group objects: by creating arrays of objects, and by creating collections of objects.

Las matrices son muy útiles para crear y trabajar con un número fijo de objetos fuertemente tipados.Arrays are most useful for creating and working with a fixed number of strongly-typed objects. Para obtener información sobre las matrices, vea Matrices.For information about arrays, see Arrays.

Las colecciones proporcionan una manera más flexible de trabajar con grupos de objetos.Collections provide a more flexible way to work with groups of objects. A diferencia de las matrices, el grupo de objetos con el que trabaja puede aumentar y reducirse de manera dinámica a medida que cambian las necesidades de la aplicación.Unlike arrays, the group of objects you work with can grow and shrink dynamically as the needs of the application change. Para algunas colecciones, puede asignar una clave a cualquier objeto que incluya en la colección para, de este modo, recuperar rápidamente el objeto con la clave.For some collections, you can assign a key to any object that you put into the collection so that you can quickly retrieve the object by using the key.

Una colección es una clase, por lo que debe declarar una instancia de la clase para poder agregar elementos a dicha colección.A collection is a class, so you must declare an instance of the class before you can add elements to that collection.

Si la colección contiene elementos de un solo tipo de datos, puede usar una de las clases del espacio de nombres System.Collections.Generic.If your collection contains elements of only one data type, you can use one of the classes in the System.Collections.Generic namespace. Una colección genérica cumple la seguridad de tipos para que ningún otro tipo de datos se pueda agregar a ella.A generic collection enforces type safety so that no other data type can be added to it. Cuando recupera un elemento de una colección genérica, no tiene que determinar su tipo de datos ni convertirlo.When you retrieve an element from a generic collection, you do not have to determine its data type or convert it.

Nota

Para los ejemplos de este tema, incluya las directivas using para los espacios de nombres System.Collections.Generic y System.Linq.For the examples in this topic, include using directives for the System.Collections.Generic and System.Linq namespaces.

En este temaIn this topic

Uso de una colección SimpleUsing a Simple Collection

Los ejemplos de esta sección usan la clase genérica List<T>, que le permite trabajar con una lista de objetos fuertemente tipados.The examples in this section use the generic List<T> class, which enables you to work with a strongly typed list of objects.

En el ejemplo siguiente se crea una lista de cadenas y luego se recorren en iteración mediante una instrucción foreach.The following example creates a list of strings and then iterates through the strings by using a foreach statement.

// Create a list of strings.
var salmons = new List<string>();
salmons.Add("chinook");
salmons.Add("coho");
salmons.Add("pink");
salmons.Add("sockeye");

// Iterate through the list.
foreach (var salmon in salmons)
{
    Console.Write(salmon + " ");
}
// Output: chinook coho pink sockeye

Si el contenido de una colección se conoce de antemano, puede usar un inicializador de colección para inicializar la colección.If the contents of a collection are known in advance, you can use a collection initializer to initialize the collection. Para obtener más información, vea Inicializadores de objeto y colección.For more information, see Object and Collection Initializers.

El ejemplo siguiente es el mismo que el ejemplo anterior, excepto que se usa un inicializador de colección para agregar elementos a la colección.The following example is the same as the previous example, except a collection initializer is used to add elements to the collection.

// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };

// Iterate through the list.
foreach (var salmon in salmons)
{
    Console.Write(salmon + " ");
}
// Output: chinook coho pink sockeye

Puede usar una instrucción for en lugar de una instrucción foreach para recorrer en iteración una colección.You can use a for statement instead of a foreach statement to iterate through a collection. Esto se consigue con el acceso a los elementos de la colección mediante la posición de índice.You accomplish this by accessing the collection elements by the index position. El índice de los elementos comienza en 0 y termina en el número de elementos menos 1.The index of the elements starts at 0 and ends at the element count minus 1.

El ejemplo siguiente recorre en iteración los elementos de una colección mediante for en lugar de foreach.The following example iterates through the elements of a collection by using for instead of foreach.

// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };

for (var index = 0; index < salmons.Count; index++)
{
    Console.Write(salmons[index] + " ");
}
// Output: chinook coho pink sockeye

El ejemplo siguiente quita un elemento de la colección especificando el objeto que se quitará.The following example removes an element from the collection by specifying the object to remove.

// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };

// Remove an element from the list by specifying
// the object.
salmons.Remove("coho");

// Iterate through the list.
foreach (var salmon in salmons)
{
    Console.Write(salmon + " ");
}
// Output: chinook pink sockeye

El ejemplo siguiente quita elementos de una lista genérica.The following example removes elements from a generic list. En lugar de una instrucción foreach, se usa una instrucción for que procesa una iteración en orden descendente.Instead of a foreach statement, a for statement that iterates in descending order is used. Esto es porque el método RemoveAt hace que los elementos después de un elemento quitado tengan un valor de índice inferior.This is because the RemoveAt method causes elements after a removed element to have a lower index value.

var numbers = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// Remove odd numbers.
for (var index = numbers.Count - 1; index >= 0; index--)
{
    if (numbers[index] % 2 == 1)
    {
        // Remove the element by specifying
        // the zero-based index in the list.
        numbers.RemoveAt(index);
    }
}

// Iterate through the list.
// A lambda expression is placed in the ForEach method
// of the List(T) object.
numbers.ForEach(
    number => Console.Write(number + " "));
// Output: 0 2 4 6 8

Para el tipo de elementos de List<T>, también puede definir su propia clase.For the type of elements in the List<T>, you can also define your own class. En el ejemplo siguiente, la clase Galaxy que usa List<T> se define en el código.In the following example, the Galaxy class that is used by the List<T> is defined in the code.

private static void IterateThroughList()
{
    var theGalaxies = new List<Galaxy>
        {
            new Galaxy() { Name="Tadpole", MegaLightYears=400},
            new Galaxy() { Name="Pinwheel", MegaLightYears=25},
            new Galaxy() { Name="Milky Way", MegaLightYears=0},
            new Galaxy() { Name="Andromeda", MegaLightYears=3}
        };

    foreach (Galaxy theGalaxy in theGalaxies)
    {
        Console.WriteLine(theGalaxy.Name + "  " + theGalaxy.MegaLightYears);
    }

    // Output:
    //  Tadpole  400
    //  Pinwheel  25
    //  Milky Way  0
    //  Andromeda  3
}

public class Galaxy
{
    public string Name { get; set; }
    public int MegaLightYears { get; set; }
}

Tipos de coleccionesKinds of Collections

.NET Framework proporciona muchas colecciones comunes.Many common collections are provided by the .NET Framework. Cada tipo de colección está diseñado para un fin específico.Each type of collection is designed for a specific purpose.

En esta sección se describen algunas de las clases de colecciones comunes:Some of the common collection classes are described in this section:

Clases System.Collections.GenericSystem.Collections.Generic Classes

Puede crear una colección genérica mediante una de las clases del espacio de nombres System.Collections.Generic.You can create a generic collection by using one of the classes in the System.Collections.Generic namespace. Una colección genérica es útil cuando todos los elementos de la colección tienen el mismo tipo.A generic collection is useful when every item in the collection has the same data type. Una colección genérica exige el establecimiento de fuertes tipos al permitir agregar solo los tipos de datos deseados.A generic collection enforces strong typing by allowing only the desired data type to be added.

En la tabla siguiente se enumeran algunas de las clases usadas con frecuencia del espacio de nombres System.Collections.Generic:The following table lists some of the frequently used classes of the System.Collections.Generic namespace:

ClaseClass DESCRIPCIÓNDescription
Dictionary<TKey,TValue> Representa una colección de pares de clave y valor que se organizan según la clave.Represents a collection of key/value pairs that are organized based on the key.
List<T> Representa una lista de objetos a los que puede tener acceso el índice.Represents a list of objects that can be accessed by index. Proporciona métodos para buscar, ordenar y modificar listas.Provides methods to search, sort, and modify lists.
Queue<T> Representa una colección de objetos de primeras entradas, primeras salidas (FIFO).Represents a first in, first out (FIFO) collection of objects.
SortedList<TKey,TValue> Representa una colección de pares clave-valor que se ordenan por claves según la implementación de IComparer<T> asociada.Represents a collection of key/value pairs that are sorted by key based on the associated IComparer<T> implementation.
Stack<T> Representa una colección de objetos de últimas entradas, primeras salidas (LIFO).Represents a last in, first out (LIFO) collection of objects.

Para obtener más información, vea Tipos de colección utilizados normalmente, Seleccionar una clase de colección y System.Collections.Generic.For additional information, see Commonly Used Collection Types, Selecting a Collection Class, and System.Collections.Generic.

Clases System.Collections.ConcurrentSystem.Collections.Concurrent Classes

En .NET Framework 4 o posterior, las colecciones del espacio de nombres System.Collections.Concurrent proporcionan operaciones eficaces y seguras para subprocesos con el fin de obtener acceso a los elementos de la colección desde varios subprocesos.In the .NET Framework 4 or newer, the collections in the System.Collections.Concurrent namespace provide efficient thread-safe operations for accessing collection items from multiple threads.

Las clases del espacio de nombres System.Collections.Concurrent deben usarse en lugar de los tipos correspondientes de los espacios de nombres System.Collections.Generic y System.Collections cada vez que varios subprocesos tengan acceso de manera simultánea a la colección.The classes in the System.Collections.Concurrent namespace should be used instead of the corresponding types in the System.Collections.Generic and System.Collections namespaces whenever multiple threads are accessing the collection concurrently. Para obtener más información, vea Colecciones seguras para subprocesos y System.Collections.Concurrent.For more information, see Thread-Safe Collections and System.Collections.Concurrent.

Algunas clases incluidas en el espacio de nombres System.Collections.Concurrent son BlockingCollection<T>, ConcurrentDictionary<TKey,TValue>, ConcurrentQueue<T> y ConcurrentStack<T>.Some classes included in the System.Collections.Concurrent namespace are BlockingCollection<T>, ConcurrentDictionary<TKey,TValue>, ConcurrentQueue<T>, and ConcurrentStack<T>.

Clases System.CollectionsSystem.Collections Classes

Las clases del espacio de nombres System.Collections no almacenan los elementos como objetos de tipo específico, sino como objetos del tipo Object.The classes in the System.Collections namespace do not store elements as specifically typed objects, but as objects of type Object.

Siempre que sea posible, debe usar las colecciones genéricas del espacio de nombres System.Collections.Generic o del espacio de nombres System.Collections.Concurrent en lugar de los tipos heredados del espacio de nombres System.Collections.Whenever possible, you should use the generic collections in the System.Collections.Generic namespace or the System.Collections.Concurrent namespace instead of the legacy types in the System.Collections namespace.

En la siguiente tabla se enumeran algunas de las clases usadas con frecuencia en el espacio de nombres System.Collections:The following table lists some of the frequently used classes in the System.Collections namespace:

ClaseClass DESCRIPCIÓNDescription
ArrayList Representa una matriz cuyo tamaño aumenta dinámicamente cuando es necesario.Represents an array of objects whose size is dynamically increased as required.
Hashtable Representa una colección de pares de clave y valor que se organizan por código hash de la clave.Represents a collection of key/value pairs that are organized based on the hash code of the key.
Queue Representa una colección de objetos de primeras entradas, primeras salidas (FIFO).Represents a first in, first out (FIFO) collection of objects.
Stack Representa una colección de objetos de últimas entradas, primeras salidas (LIFO).Represents a last in, first out (LIFO) collection of objects.

El espacio de nombres System.Collections.Specialized proporciona clases de colección especializadas y fuertemente tipadas como, por ejemplo, colecciones de solo cadena y diccionarios híbridos y de lista vinculada.The System.Collections.Specialized namespace provides specialized and strongly typed collection classes, such as string-only collections and linked-list and hybrid dictionaries.

Implementación de una colección de pares de clave/valorImplementing a Collection of Key/Value Pairs

La colección genérica Dictionary<TKey,TValue> le permite tener acceso a los elementos de una colección con la clave de cada elemento.The Dictionary<TKey,TValue> generic collection enables you to access to elements in a collection by using the key of each element. Cada adición al diccionario consta de un valor y de su clave asociada.Each addition to the dictionary consists of a value and its associated key. Recuperar un valor usando su clave es rápido porque la clase Dictionary se implementa como una tabla hash.Retrieving a value by using its key is fast because the Dictionary class is implemented as a hash table.

En el ejemplo siguiente se crea una colección Dictionary y se recorre en iteración el diccionario usando una instrucción foreach.The following example creates a Dictionary collection and iterates through the dictionary by using a foreach statement.

private static void IterateThruDictionary()
{
    Dictionary<string, Element> elements = BuildDictionary();

    foreach (KeyValuePair<string, Element> kvp in elements)
    {
        Element theElement = kvp.Value;

        Console.WriteLine("key: " + kvp.Key);
        Console.WriteLine("values: " + theElement.Symbol + " " +
            theElement.Name + " " + theElement.AtomicNumber);
    }
}

private static Dictionary<string, Element> BuildDictionary()
{
    var elements = new Dictionary<string, Element>();

    AddToDictionary(elements, "K", "Potassium", 19);
    AddToDictionary(elements, "Ca", "Calcium", 20);
    AddToDictionary(elements, "Sc", "Scandium", 21);
    AddToDictionary(elements, "Ti", "Titanium", 22);

    return elements;
}

private static void AddToDictionary(Dictionary<string, Element> elements,
    string symbol, string name, int atomicNumber)
{
    Element theElement = new Element();

    theElement.Symbol = symbol;
    theElement.Name = name;
    theElement.AtomicNumber = atomicNumber;

    elements.Add(key: theElement.Symbol, value: theElement);
}

public class Element
{
    public string Symbol { get; set; }
    public string Name { get; set; }
    public int AtomicNumber { get; set; }
}

Para usar un inicializador de colección para compilar la colección Dictionary, puede reemplazar los métodos BuildDictionary y AddToDictionary por el método siguiente.To instead use a collection initializer to build the Dictionary collection, you can replace the BuildDictionary and AddToDictionary methods with the following method.

private static Dictionary<string, Element> BuildDictionary2()
{
    return new Dictionary<string, Element>
    {
        {"K",
            new Element() { Symbol="K", Name="Potassium", AtomicNumber=19}},
        {"Ca",
            new Element() { Symbol="Ca", Name="Calcium", AtomicNumber=20}},
        {"Sc",
            new Element() { Symbol="Sc", Name="Scandium", AtomicNumber=21}},
        {"Ti",
            new Element() { Symbol="Ti", Name="Titanium", AtomicNumber=22}}
    };
}

En el ejemplo siguiente se usa el método ContainsKey y la propiedad Item[TKey] de Dictionary para encontrar rápidamente un elemento por clave.The following example uses the ContainsKey method and the Item[TKey] property of Dictionary to quickly find an item by key. La propiedad Item le permite tener acceso a un elemento de la colección elements usando elements[symbol] en C#.The Item property enables you to access an item in the elements collection by using the elements[symbol] in C#.

private static void FindInDictionary(string symbol)
{
    Dictionary<string, Element> elements = BuildDictionary();

    if (elements.ContainsKey(symbol) == false)
    {
        Console.WriteLine(symbol + " not found");
    }
    else
    {
        Element theElement = elements[symbol];
        Console.WriteLine("found: " + theElement.Name);
    }
}

En el ejemplo siguiente se usa en su lugar el método TryGetValue para encontrar rápidamente un elemento por clave.The following example instead uses the TryGetValue method quickly find an item by key.

private static void FindInDictionary2(string symbol)
{
    Dictionary<string, Element> elements = BuildDictionary();

    Element theElement = null;
    if (elements.TryGetValue(symbol, out theElement) == false)
        Console.WriteLine(symbol + " not found");
    else
        Console.WriteLine("found: " + theElement.Name);
}

Uso de LINQ para tener acceso a una colecciónUsing LINQ to Access a Collection

LINQ (Language-Integrated Query) puede usar para tener acceso a las colecciones.LINQ (Language-Integrated Query) can be used to access collections. Las consultas LINQ proporcionan capacidades de filtrado, ordenación y agrupación.LINQ queries provide filtering, ordering, and grouping capabilities. Para obtener más información, vea Introducción a LINQ en C#.For more information, see Getting Started with LINQ in C#.

El ejemplo siguiente ejecuta una consulta LINQ en una List genérica.The following example runs a LINQ query against a generic List. La consulta LINQ devuelve otra colección que contiene los resultados.The LINQ query returns a different collection that contains the results.

private static void ShowLINQ()
{
    List<Element> elements = BuildList();

    // LINQ Query.
    var subset = from theElement in elements
                 where theElement.AtomicNumber < 22
                 orderby theElement.Name
                 select theElement;

    foreach (Element theElement in subset)
    {
        Console.WriteLine(theElement.Name + " " + theElement.AtomicNumber);
    }

    // Output:
    //  Calcium 20
    //  Potassium 19
    //  Scandium 21
}

private static List<Element> BuildList()
{
    return new List<Element>
    {
        { new Element() { Symbol="K", Name="Potassium", AtomicNumber=19}},
        { new Element() { Symbol="Ca", Name="Calcium", AtomicNumber=20}},
        { new Element() { Symbol="Sc", Name="Scandium", AtomicNumber=21}},
        { new Element() { Symbol="Ti", Name="Titanium", AtomicNumber=22}}
    };
}

public class Element
{
    public string Symbol { get; set; }
    public string Name { get; set; }
    public int AtomicNumber { get; set; }
}

Ordenar una colecciónSorting a Collection

En el ejemplo siguiente se muestra un procedimiento para ordenar una colección.The following example illustrates a procedure for sorting a collection. El ejemplo ordena las instancias de la clase Car que se almacenan en un List<T>.The example sorts instances of the Car class that are stored in a List<T>. La clase Car implementa la interfaz IComparable<T>, que requiere implementar el método CompareTo.The Car class implements the IComparable<T> interface, which requires that the CompareTo method be implemented.

Cada llamada al método CompareTo realiza una comparación única que se usa para la ordenación.Each call to the CompareTo method makes a single comparison that is used for sorting. El código escrito por el usuario en el método CompareTo devuelve un valor para cada comparación del objeto actual con otro objeto.User-written code in the CompareTo method returns a value for each comparison of the current object with another object. El valor devuelto es menor que cero si el objeto actual es menor que el otro objeto, mayor que cero si el objeto actual es mayor que el otro objeto y cero si son iguales.The value returned is less than zero if the current object is less than the other object, greater than zero if the current object is greater than the other object, and zero if they are equal. Esto permite definir en el código los criterios de mayor que, menor que e igual.This enables you to define in code the criteria for greater than, less than, and equal.

En el método ListCars, la instrucción cars.Sort() ordena la lista.In the ListCars method, the cars.Sort() statement sorts the list. Esta llamada al método Sort de List<T> hace que se llame automáticamente al método CompareTo para los objetos Car de List.This call to the Sort method of the List<T> causes the CompareTo method to be called automatically for the Car objects in the List.

private static void ListCars()
{
    var cars = new List<Car>
    {
        { new Car() { Name = "car1", Color = "blue", Speed = 20}},
        { new Car() { Name = "car2", Color = "red", Speed = 50}},
        { new Car() { Name = "car3", Color = "green", Speed = 10}},
        { new Car() { Name = "car4", Color = "blue", Speed = 50}},
        { new Car() { Name = "car5", Color = "blue", Speed = 30}},
        { new Car() { Name = "car6", Color = "red", Speed = 60}},
        { new Car() { Name = "car7", Color = "green", Speed = 50}}
    };

    // Sort the cars by color alphabetically, and then by speed
    // in descending order.
    cars.Sort();

    // View all of the cars.
    foreach (Car thisCar in cars)
    {
        Console.Write(thisCar.Color.PadRight(5) + " ");
        Console.Write(thisCar.Speed.ToString() + " ");
        Console.Write(thisCar.Name);
        Console.WriteLine();
    }

    // Output:
    //  blue  50 car4
    //  blue  30 car5
    //  blue  20 car1
    //  green 50 car7
    //  green 10 car3
    //  red   60 car6
    //  red   50 car2
}

public class Car : IComparable<Car>
{
    public string Name { get; set; }
    public int Speed { get; set; }
    public string Color { get; set; }

    public int CompareTo(Car other)
    {
        // A call to this method makes a single comparison that is
        // used for sorting.

        // Determine the relative order of the objects being compared.
        // Sort by color alphabetically, and then by speed in
        // descending order.

        // Compare the colors.
        int compare;
        compare = String.Compare(this.Color, other.Color, true);

        // If the colors are the same, compare the speeds.
        if (compare == 0)
        {
            compare = this.Speed.CompareTo(other.Speed);

            // Use descending order for speed.
            compare = -compare;
        }

        return compare;
    }
}

Definición de una colección personalizadaDefining a Custom Collection

Puede definir una colección implementando la interfaz IEnumerable<T> o IEnumerable.You can define a collection by implementing the IEnumerable<T> or IEnumerable interface.

Aunque puede definir una colección personalizada, es mejor usar las colecciones incluidas en .NET Framework. Estas colecciones se describen en la sección Tipos de colecciones de este tema.Although you can define a custom collection, it is usually better to instead use the collections that are included in the .NET Framework, which are described in Kinds of Collections earlier in this topic.

En el siguiente ejemplo se define una clase de colección personalizada denominada AllColors.The following example defines a custom collection class named AllColors. Esta clase implementa la interfaz IEnumerable que requiere implementar el método GetEnumerator.This class implements the IEnumerable interface, which requires that the GetEnumerator method be implemented.

El método GetEnumerator devuelve una instancia de la clase ColorEnumerator.The GetEnumerator method returns an instance of the ColorEnumerator class. ColorEnumerator implementa la interfaz IEnumerator, que requiere que la propiedad Current, el método MoveNext y el método Reset estén implementados.ColorEnumerator implements the IEnumerator interface, which requires that the Current property, MoveNext method, and Reset method be implemented.

private static void ListColors()
{
    var colors = new AllColors();

    foreach (Color theColor in colors)
    {
        Console.Write(theColor.Name + " ");
    }
    Console.WriteLine();
    // Output: red blue green
}

// Collection class.
public class AllColors : System.Collections.IEnumerable
{
    Color[] _colors =
    {
        new Color() { Name = "red" },
        new Color() { Name = "blue" },
        new Color() { Name = "green" }
    };

    public System.Collections.IEnumerator GetEnumerator()
    {
        return new ColorEnumerator(_colors);

        // Instead of creating a custom enumerator, you could
        // use the GetEnumerator of the array.
        //return _colors.GetEnumerator();
    }

    // Custom enumerator.
    private class ColorEnumerator : System.Collections.IEnumerator
    {
        private Color[] _colors;
        private int _position = -1;

        public ColorEnumerator(Color[] colors)
        {
            _colors = colors;
        }

        object System.Collections.IEnumerator.Current
        {
            get
            {
                return _colors[_position];
            }
        }

        bool System.Collections.IEnumerator.MoveNext()
        {
            _position++;
            return (_position < _colors.Length);
        }

        void System.Collections.IEnumerator.Reset()
        {
            _position = -1;
        }
    }
}

// Element class.
public class Color
{
    public string Name { get; set; }
}

IteratorsIterators

Los iteradores se usan para efectuar una iteración personalizada en una colección.An iterator is used to perform a custom iteration over a collection. Un iterador puede ser un método o un descriptor de acceso get.An iterator can be a method or a get accessor. Un iterador usa una instrucción yield return para devolver cada elemento de la colección a la vez.An iterator uses a yield return statement to return each element of the collection one at a time.

Llame a un iterador mediante una instrucción foreach.You call an iterator by using a foreach statement. Cada iteración del bucle foreach llama al iterador.Each iteration of the foreach loop calls the iterator. Cuando se alcanza una instrucción yield return en el iterador, se devuelve una expresión y se conserva la ubicación actual en el código.When a yield return statement is reached in the iterator, an expression is returned, and the current location in code is retained. La ejecución se reinicia desde esa ubicación la próxima vez que se llama al iterador.Execution is restarted from that location the next time that the iterator is called.

Para obtener más información, vea Iterators (C#) (Iteradores (C#)).For more information, see Iterators (C#).

El siguiente ejemplo usa el método del iterador.The following example uses an iterator method. El método del iterador tiene una instrucción yield return que se encuentra dentro de un bucle for.The iterator method has a yield return statement that is inside a for loop. En el método ListEvenNumbers, cada iteración del cuerpo de la instrucción foreach crea una llamada al método iterador, que continúa con la siguiente instrucción yield return.In the ListEvenNumbers method, each iteration of the foreach statement body creates a call to the iterator method, which proceeds to the next yield return statement.

private static void ListEvenNumbers()
{
    foreach (int number in EvenSequence(5, 18))
    {
        Console.Write(number.ToString() + " ");
    }
    Console.WriteLine();
    // Output: 6 8 10 12 14 16 18
}

private static IEnumerable<int> EvenSequence(
    int firstNumber, int lastNumber)
{
    // Yield even numbers in the range.
    for (var number = firstNumber; number <= lastNumber; number++)
    {
        if (number % 2 == 0)
        {
            yield return number;
        }
    }
}

Vea tambiénSee also