C # Itreator mejor enfoque

Question

Aparte de (IEnumerable Returns GetEnumerator (), para " foreach " IEnumerble es esencial)

casi los siguientes dos enfoques nos permiten iterar sobre la colección. Qué es

la ventaja de uno sobre otro? (No estoy preguntando la diferencia entre IEnumerable y IEnumerator).

static void Main()
{
    IEnumerator<int> em = MyEnumerator<int>(new int[] { 1, 2, 3, 4 });
    IEnumerator<int> e = Collection<int>
                        (new int[] { 1, 2, 3, 4 }).GetEnumerator();

    while (em.MoveNext())
    {
        Console.WriteLine(em.Current);
    }

    while (e.MoveNext())
    {
        Console.WriteLine(e.Current);
    }
    Console.ReadKey(true);
}

enfoque 1

 public static IEnumerator<T> MyEnumerator<T>(T[] vals )

 {
     T[] some = vals;

     foreach (var v in some)
     {
       yield return v;
     }
}

enfoque 2

public static IEnumerable<T> Collection<T>(T[] vals)
     {
         T[] some = vals;

         foreach (var v in some)
         {
             yield return v;
         }
     }

Answer 1

La principal diferencia es que la mayoría de las API admiten una entrada de IEnumerable<T> pero no de IEnumerator<T>.

También debe recordar llamar a Reset () cuando lo use, mientras que la sintaxis es más evidente en GetEnumerator (simplemente llame de nuevo a RandomEnumerable). También vea el comentario de Eric Lipper acerca de que reiniciar es una mala idea; si Reset no está implementado en su RangeEnumerable o tiene errores, se convierte en un enumerador único (bastante inútil en muchos casos).

Otra diferencia puede ser que podría tener un Reset() que podría enumerarse desde varios subprocesos al mismo tiempo pero un <=> almacenar una posición en los datos enumerados (Imagine un <=> o <=>).

Entonces, la conclusión es que <=> es más versátil, pero de todos modos si tiene una función que devuelve un <=> generando el <=> alrededor es simple.

class EnumeratorWrapper<T> : IEnumerable<T>
{
    Func<IEnumerator<T>> m_generator;
    public EnumeratorWrapper(Func<IEnumerator<T>> generator)
    {
        m_generator = generator;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return m_generator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return m_generator();
    }
}

Solo por la consistencia API usando <=> me parece la mejor solución.

Pero el problema con <=> en <=> lo convierte en una solución inutilizable de todos modos, por lo que <=> es el camino a seguir.

Answer 2

Corrígeme si me equivoco, pero la única diferencia es la diferencia entre IEnumerable e IEnumerator y, dado que dijiste específicamente que no estás preguntando la diferencia, ambas son buenas ...