ottenere un enumeratore generico da un array

In C #, come si ottiene un enumeratore generico da un dato array?

Nel codice seguente, MyArrayc'è un array di MyTypeoggetti. Vorrei ottenere MyIEnumeratornella moda mostrata, ma sembra che ottengo un enumeratore vuoto (anche se l'ho confermato MyArray.Length > 0).

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

Funziona su 2.0+:

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

Funziona su 3.5+ (LINQy fantasia, un po 'meno efficiente):

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

Puoi decidere da solo se il casting è abbastanza brutto da giustificare una chiamata di libreria estranea:

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 per completezza, si dovrebbe anche notare che quanto segue non è corretto - e andrà in crash in fase di esecuzione - perché T[]sceglie l' interfaccia non generica IEnumerableper la sua implementazione predefinita (cioè non esplicita) di 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>
}

Il mistero è, perché non SZGenericArrayEnumerator<T>eredita da SZArrayEnumerator- una classe interna che è attualmente contrassegnata come "sealed" - poiché ciò consentirebbe di restituire l'enumeratore generico (covariante) per impostazione predefinita?

Dato che non mi piace il casting, un piccolo aggiornamento:

your_array.AsEnumerable().GetEnumerator();

Per renderlo il più pulito possibile, mi piace lasciare che il compilatore faccia tutto il lavoro. Non ci sono cast (quindi è effettivamente indipendente dai tipi). Non vengono utilizzate librerie di terze parti (System.Linq) (nessun overhead di runtime).

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

// E per usare il codice:

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

Questo sfrutta un po 'di magia del compilatore che mantiene tutto pulito.

L'altro punto da notare è che la mia risposta è l'unica che eseguirà il controllo in fase di compilazione.

Per una qualsiasi delle altre soluzioni, se il tipo di "arr" cambia, il codice chiamante verrà compilato e avrà esito negativo in fase di esecuzione, determinando un bug di runtime.

La mia risposta farà sì che il codice non venga compilato e quindi ho meno possibilità di inviare un bug nel mio codice, poiché mi segnalerebbe che sto usando il tipo sbagliato.

YourArray.OfType (). GetEnumerator ();

può funzionare un po 'meglio, poiché deve solo controllare il tipo e non lanciare.

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

    IEnumerable<MyType> enumerable = arr;

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

    foreach (MyType item in enumerable)
    {

    }

Quello che puoi fare, ovviamente, è semplicemente implementare il tuo enumeratore generico per gli array.

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

Questo è più o meno uguale all'implementazione .NET di SZGenericArrayEnumerator <T> come menzionato da Glenn Slayden. Ovviamente dovresti farlo solo nei casi in cui ne vale la pena. Nella maggior parte dei casi non lo è.