mendapatkan pencacah generik dari array

Dalam C #, bagaimana seseorang mendapatkan pencacah generik dari larik yang diberikan?

Dalam kode di bawah ini, MyArrayadalah larik MyTypeobjek. Saya ingin mendapatkan MyIEnumeratordalam mode yang ditunjukkan, tetapi tampaknya saya mendapatkan pencacah kosong (meskipun saya sudah memastikannya MyArray.Length > 0).

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

Bekerja pada 2.0+:

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

Bekerja pada 3.5+ (LINQy mewah, sedikit kurang efisien):

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

Anda dapat memutuskan sendiri apakah casting cukup jelek untuk menjamin panggilan perpustakaan yang tidak relevan:

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

Dan untuk kelengkapan, kita juga harus mencatat bahwa berikut ini tidak benar - dan akan macet saat runtime - karena T[]memilih antarmuka non- generik IEnumerableuntuk implementasi defaultnya (yaitu non-eksplisit) 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>
}

Misterinya adalah, mengapa tidak SZGenericArrayEnumerator<T>mewarisi dari - SZArrayEnumeratorkelas internal yang saat ini ditandai 'disegel' - karena ini akan memungkinkan pencacah umum (kovarian) dikembalikan secara default?

Karena saya tidak suka mentransmisi, sedikit pembaruan:

your_array.AsEnumerable().GetEnumerator();

Untuk membuatnya sebersih mungkin saya ingin membiarkan compiler melakukan semua pekerjaan. Tidak ada gips (jadi tipe ini aman). Tidak ada Library pihak ketiga (System.Linq) yang digunakan (Tanpa overhead runtime).

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

// Dan untuk menggunakan kode:

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

Ini memanfaatkan beberapa keajaiban kompiler yang menjaga semuanya tetap bersih.

Hal lain yang perlu diperhatikan adalah bahwa jawaban saya adalah satu-satunya jawaban yang akan melakukan pengecekan waktu kompilasi.

Untuk solusi lain yang mana pun jika jenis "arr" berubah, maka kode pemanggil akan dikompilasi, dan gagal saat runtime, yang mengakibatkan bug runtime.

Jawaban saya akan menyebabkan kode tidak dapat dikompilasi dan oleh karena itu peluang saya untuk mengirimkan bug dalam kode saya lebih kecil, karena ini akan memberi sinyal kepada saya bahwa saya menggunakan jenis yang salah.

YourArray.OfType (). GetEnumerator ();

mungkin bekerja sedikit lebih baik, karena hanya perlu memeriksa jenisnya, dan tidak melakukan cast.

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

    IEnumerable<MyType> enumerable = arr;

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

    foreach (MyType item in enumerable)
    {

    }

Yang dapat Anda lakukan, tentu saja, hanyalah mengimplementasikan enumerator generik Anda sendiri untuk 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. */}
    }
}

Ini kurang lebih sama dengan implementasi .NET dari SZGenericArrayEnumerator <T> seperti yang disebutkan oleh Glenn Slayden. Anda tentu saja harus melakukan ini, jika ini sepadan dengan usaha. Dalam banyak kasus tidak.