obter enumerador genérico de uma matriz

Em C #, como se obtém um enumerador genérico de uma determinada matriz?

No código abaixo, MyArrayé uma matriz de MyTypeobjetos. Gostaria de obter MyIEnumeratorda forma indicada, mas parece que obtenho um enumerador vazio (embora o tenha confirmado MyArray.Length > 0).

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

Funciona em 2.0+:

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

Funciona em 3.5+ (LINQy sofisticado, um pouco menos eficiente):

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

Você pode decidir por si mesmo se o elenco é feio o suficiente para justificar uma chamada externa à 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()
}

E para completar, deve-se observar também que o seguinte não está correto - e irá travar em tempo de execução - porque T[]escolhe a interface não genérica IEnumerablepara sua implementação padrão (ou seja, não 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>
}

O mistério é: por que não SZGenericArrayEnumerator<T>herda de SZArrayEnumerator- uma classe interna que atualmente está marcada como 'selada' - já que isso permitiria que o enumerador genérico (covariante) fosse retornado por padrão?

Já que não gosto de lançar, uma pequena atualização:

your_array.AsEnumerable().GetEnumerator();

Para deixar o mais limpo possível, gosto de deixar o compilador fazer todo o trabalho. Não há casts (portanto, é realmente seguro para tipos). Nenhuma biblioteca de terceiros (System.Linq) é usada (sem sobrecarga de tempo de execução).

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

// E para usar o código:

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

Isso tira vantagem de alguma mágica do compilador que mantém tudo limpo.

O outro ponto a ser observado é que minha resposta é a única que fará a verificação em tempo de compilação.

Para qualquer uma das outras soluções, se o tipo de "arr" mudar, o código de chamada será compilado e falhará no tempo de execução, resultando em um bug de tempo de execução.

Minha resposta fará com que o código não compile e, portanto, tenho menos chance de enviar um bug no meu código, pois isso me indicaria que estou usando o tipo errado.

YourArray.OfType (). GetEnumerator ();

pode ter um desempenho um pouco melhor, já que só tem que verificar o tipo, e não lançar.

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

    IEnumerable<MyType> enumerable = arr;

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

    foreach (MyType item in enumerable)
    {

    }

O que você pode fazer, é claro, é apenas implementar seu próprio enumerador genérico para arrays.

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. */}
    }
}

Isso é mais ou menos igual à implementação do .NET de SZGenericArrayEnumerator <T> conforme mencionado por Glenn Slayden. É claro que você só deve fazer isso nos casos em que vale a pena o esforço. Na maioria dos casos, não é.