obtener un enumerador genérico de una matriz

En C #, ¿cómo se obtiene un enumerador genérico de una matriz determinada?

En el código siguiente, MyArrayhay una matriz de MyTypeobjetos. Me gustaría obtener MyIEnumeratorde la manera que se muestra, pero parece que obtengo un enumerador vacío (aunque lo he confirmado MyArray.Length > 0).

MyType[] MyArray = ... ;
IEnumerator<MyType> MyIEnumerator = MyArray.GetEnumerator() as IEnumerator<MyType>;

Funciona en 2.0+:

((IEnumerable<MyType>)myArray).GetEnumerator()

Funciona en 3.5+ (LINQy elegante, un poco menos eficiente):

myArray.Cast<MyType>().GetEnumerator()   // returns IEnumerator<MyType>

Puedes decidir por ti mismo si la transmisión es lo suficientemente fea como para justificar una llamada ajena a la biblioteca:

int[] arr;
IEnumerator<int> Get1()
{
    return ((IEnumerable<int>)arr).GetEnumerator();  // <-- 1 non-local call

    // ldarg.0 
    // ldfld int32[] foo::arr
    // castclass System.Collections.Generic.IEnumerable`1<int32>
    // callvirt instance class System.Collections.Generic.IEnumerator`1<!0> System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
}

IEnumerator<int> Get2()
{
    return arr.AsEnumerable().GetEnumerator();   // <-- 2 non-local calls

    // ldarg.0 
    // ldfld int32[] foo::arr
    // call class System.Collections.Generic.IEnumerable`1<!!0> System.Linq.Enumerable::AsEnumerable<int32>(class System.Collections.Generic.IEnumerable`1<!!0>)
    // callvirt instance class System.Collections.Generic.IEnumerator`1<!0> System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
}

Y para completar, también se debe tener en cuenta que lo siguiente no es correcto, y se bloqueará en tiempo de ejecución, porque T[]elige la interfaz no genérica IEnumerablepara su implementación predeterminada (es decir, no explícita) de GetEnumerator().

IEnumerator<int> NoGet()                    // error - do not use
{
    return (IEnumerator<int>)arr.GetEnumerator();

    // ldarg.0 
    // ldfld int32[] foo::arr
    // callvirt instance class System.Collections.IEnumerator System.Array::GetEnumerator()
    // castclass System.Collections.Generic.IEnumerator`1<int32>
}

El misterio es, ¿por qué no SZGenericArrayEnumerator<T>hereda de SZArrayEnumeratoruna clase interna que actualmente está marcada como 'sellada', ya que esto permitiría que el enumerador genérico (covariante) se devuelva de forma predeterminada?

Como no me gusta el casting, una pequeña actualización:

your_array.AsEnumerable().GetEnumerator();

Para hacerlo lo más limpio posible, me gusta dejar que el compilador haga todo el trabajo. No hay yesos (por lo que en realidad es seguro para tipos). No se utilizan bibliotecas de terceros (System.Linq) (sin sobrecarga de tiempo de ejecución).

    public static IEnumerable<T> GetEnumerable<T>(this T[] arr)
    {
        return arr;
    }

// Y para usar el código:

    String[] arr = new String[0];
    arr.GetEnumerable().GetEnumerator()

Esto aprovecha la magia del compilador que mantiene todo limpio.

El otro punto a tener en cuenta es que mi respuesta es la única respuesta que realizará la verificación en tiempo de compilación.

Para cualquiera de las otras soluciones, si el tipo de "arr" cambia, el código de llamada se compilará y fallará en tiempo de ejecución, lo que resultará en un error de ejecución.

Mi respuesta hará que el código no se compile y, por lo tanto, tengo menos posibilidades de enviar un error en mi código, ya que me indicaría que estoy usando el tipo incorrecto.

YourArray.OfType (). GetEnumerator ();

Puede que funcione un poco mejor, ya que solo hay que comprobar el tipo y no lanzar.

    MyType[] arr = { new MyType(), new MyType(), new MyType() };

    IEnumerable<MyType> enumerable = arr;

    IEnumerator<MyType> en = enumerable.GetEnumerator();

    foreach (MyType item in enumerable)
    {

    }

Lo que puede hacer, por supuesto, es implementar su propio enumerador genérico para matrices.

using System.Collections;
using System.Collections.Generic;

namespace SomeNamespace
{
    public class ArrayEnumerator<T> : IEnumerator<T>
    {
        public ArrayEnumerator(T[] arr)
        {
            collection = arr;
            length = arr.Length;
        }
        private readonly T[] collection;
        private int index = -1;
        private readonly int length;

        public T Current { get { return collection[index]; } }

        object IEnumerator.Current { get { return Current; } }

        public bool MoveNext() { index++; return index < length; }

        public void Reset() { index = -1; }

        public void Dispose() {/* Nothing to dispose. */}
    }
}

Esto es más o menos igual a la implementación .NET de SZGenericArrayEnumerator <T> como lo menciona Glenn Slayden. Por supuesto, solo debe hacer esto, en los casos en que valga la pena el esfuerzo. En la mayoría de los casos no lo es.