array - foreach var c#

Cómo usar la palabra clave foreach en Objetos personalizados en C#

Question

¿Alguien puede compartir un ejemplo simple del uso de la palabra clave foreach con objetos personalizados?

Answer 1

(Supongo C # aquí)

Si tiene una lista de objetos personalizados, puede usar el foreach de la misma forma que lo hace con cualquier otro objeto:

List<MyObject> myObjects = // something
foreach(MyObject myObject in myObjects)
{
     // Do something nifty here
}

Si desea crear su propio contenedor, puede usar la palabra clave yield (desde .Net 2.0 y hacia arriba, creo) junto con la interfaz IEnumerable.

class MyContainer : IEnumerable<int>
{
    private int max = 0;
    public MyContainer(int max)
    {
        this.max = max;
    }

    public IEnumerator<int> GetEnumerator()
    {
        for(int i = 0; i < max; ++i)
            yield return i;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Y luego usarlo con foreach:

MyContainer myContainer = new MyContainer(10);
foreach(int i in myContainer)
    Console.WriteLine(i);

Answer 2

Dadas las etiquetas, supongo que te refieres a .NET, y elegiré hablar sobre C #, ya que eso es lo que sé.

La declaración foreach (por lo general) usa IEnumerable e IEnumerator o sus primos genéricos. Una declaración de la forma:

foreach (Foo element in source)
{
    // Body
}

donde la source implementa IEnumerable<Foo> es más o menos equivalente a:

using (IEnumerator<Foo> iterator = source.GetEnumerator())
{
    Foo element;
    while (iterator.MoveNext())
    {
        element = iterator.Current;
        // Body
    }
}

Tenga en cuenta que IEnumerator<Foo> está dispuesto al final, sin embargo, la declaración se cierra. Esto es importante para los bloques de iteradores.

Para implementar IEnumerable<T> o IEnumerator<T> usted mismo, la forma más fácil es usar un bloque iterador. En lugar de escribir todos los detalles aquí, probablemente sea mejor que lo remita al capítulo 6 de C # en profundidad , que es una descarga gratuita. Todo el capítulo 6 está sobre iteradores. También tengo otros dos artículos en mi sitio C # en profundidad:

• Iteradores, bloques de iteradores y canalizaciones de datos
• Detalles de implementación del bloque iterador

Como un ejemplo rápido, sin embargo:

public IEnumerable<int> EvenNumbers0To10()
{
    for (int i=0; i <= 10; i += 2)
    {
        yield return i;
    }
}

// Later
foreach (int x in EvenNumbers0To10())
{
    Console.WriteLine(x); // 0, 2, 4, 6, 8, 10
}

Para implementar IEnumerable<T> para un tipo, puede hacer algo como:

public class Foo implements IEnumerable<string>
{
    public IEnumerator<string> GetEnumerator()
    {
        yield return "x";
        yield return "y";
    }

    // Explicit interface implementation for nongeneric interface
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator(); // Just return the generic version
    }
}