Generischen Enumerator aus einem Array abrufen

Wie erhält man in C # einen generischen Enumerator aus einem bestimmten Array?

Im folgenden Code MyArraybefindet sich ein Array von MyTypeObjekten. Ich möchte MyIEnumeratorin der gezeigten Weise erhalten, aber es scheint, dass ich einen leeren Enumerator erhalte (obwohl ich das bestätigt habe MyArray.Length > 0).

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

Funktioniert mit 2.0+:

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

Funktioniert mit 3.5+ (ausgefallenes LINQy, etwas weniger effizient):

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

Sie können selbst entscheiden, ob das Casting hässlich genug ist, um einen fremden Bibliotheksaufruf zu rechtfertigen:

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()
}

Der Vollständigkeit halber sollte man auch beachten, dass das Folgende nicht korrekt ist - und zur Laufzeit abstürzt -, da T[]die nicht generische IEnumerableSchnittstelle für ihre Standardimplementierung (dh nicht explizite) von ausgewählt wird 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>
}

Das Rätsel ist, warum nicht SZGenericArrayEnumerator<T>von SZArrayEnumeratoreiner internen Klasse geerbt wird, die derzeit als "versiegelt" gekennzeichnet ist, da dadurch der (kovariante) generische Enumerator standardmäßig zurückgegeben werden kann.

Da ich kein Casting mag, ein kleines Update:

your_array.AsEnumerable().GetEnumerator();

Um es so sauber wie möglich zu machen, lasse ich den Compiler gerne die ganze Arbeit machen. Es gibt keine Abgüsse (also ist es tatsächlich typsicher). Es werden keine Bibliotheken von Drittanbietern (System.Linq) verwendet (kein Laufzeitaufwand).

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

// Und um den Code zu verwenden:

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

Dies nutzt einige Compiler-Magie, die alles sauber hält.

Der andere zu beachtende Punkt ist, dass meine Antwort die einzige Antwort ist, die eine Überprüfung zur Kompilierungszeit durchführt.

Wenn sich bei einer der anderen Lösungen der Typ von "arr" ändert, wird der aufrufende Code kompiliert und schlägt zur Laufzeit fehl, was zu einem Laufzeitfehler führt.

Meine Antwort führt dazu, dass der Code nicht kompiliert wird und ich daher weniger Chancen habe, einen Fehler in meinem Code zu versenden, da dies mir signalisieren würde, dass ich den falschen Typ verwende.

YourArray.OfType (). GetEnumerator ();

kann etwas besser abschneiden, da nur der Typ überprüft und nicht gegossen werden muss.

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

    IEnumerable<MyType> enumerable = arr;

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

    foreach (MyType item in enumerable)
    {

    }

Sie können natürlich nur Ihren eigenen generischen Enumerator für Arrays implementieren.

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

Dies entspricht mehr oder weniger der .NET-Implementierung von SZGenericArrayEnumerator <T>, wie von Glenn Slayden erwähnt. Sie sollten dies natürlich nur tun, wenn dies die Mühe wert ist. In den meisten Fällen ist dies nicht der Fall.