lấy bảng liệt kê chung từ một mảng

Trong C #, làm cách nào để có được một kiểu liệt kê chung từ một mảng nhất định?

Trong đoạn mã dưới đây, MyArraylà một mảng các MyTypeđối tượng. Tôi muốn lấy MyIEnumeratortheo thời trang được hiển thị, nhưng có vẻ như tôi có được một điều tra viên trống (mặc dù tôi đã xác nhận điều đó MyArray.Length > 0).

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

Hoạt động trên 2.0+:

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

Hoạt động trên 3.5+ (LINQy ưa thích, kém hiệu quả hơn một chút):

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

Bạn có thể tự quyết định xem quá trình truyền có đủ xấu để đảm bảo một lệnh gọi thư viện không liên quan hay không:

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

Và cho đầy đủ, người ta cũng nên lưu ý rằng những điều sau đây là không đúng - và sẽ sụp đổ trong thời gian chạy - vì T[]chọn không -generic IEnumerablegiao diện cho mặc định của nó (tức là không rõ ràng) thực hiện 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>
}

Bí ẩn là, tại sao không SZGenericArrayEnumerator<T>kế thừa từ SZArrayEnumerator--an lớp bên trong hiện được đánh dấu là 'niêm phong' - vì điều này sẽ cho phép trả về kiểu liệt kê chung (đồng biến) theo mặc định?

Vì tôi không thích truyền, nên cập nhật một chút:

your_array.AsEnumerable().GetEnumerator();

Để làm cho nó sạch nhất có thể, tôi muốn để trình biên dịch thực hiện tất cả công việc. Không có phôi (vì vậy nó thực sự là loại an toàn). Không sử dụng Thư viện của bên thứ ba (System.Linq) (Không có chi phí thời gian chạy).

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

// Và để sử dụng mã:

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

Điều này tận dụng một số phép thuật của trình biên dịch giúp giữ mọi thứ sạch sẽ.

Điểm khác cần lưu ý là câu trả lời của tôi là câu trả lời duy nhất sẽ kiểm tra thời gian biên dịch.

Đối với bất kỳ giải pháp nào khác nếu kiểu "arr" thay đổi, thì mã gọi sẽ biên dịch và không thành công trong thời gian chạy, dẫn đến lỗi thời gian chạy.

Câu trả lời của tôi sẽ khiến mã không được biên dịch và do đó tôi ít có cơ hội gửi lỗi trong mã của mình hơn, vì nó sẽ báo hiệu cho tôi biết rằng tôi đang sử dụng sai loại.

YourArray.OfType (). GetEnumerator ();

có thể hoạt động tốt hơn một chút, vì nó chỉ phải kiểm tra loại chứ không phải ép kiểu.

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

    IEnumerable<MyType> enumerable = arr;

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

    foreach (MyType item in enumerable)
    {

    }

Tất nhiên, những gì bạn có thể làm chỉ là triển khai kiểu liệt kê chung của riêng bạn cho các mảng.

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

Điều này ít nhiều tương đương với việc nhập .NET của SZGenericArrayEnumerator <T> như Glenn Slayden đã đề cập. Tất nhiên bạn chỉ nên làm điều này, đây là những trường hợp đáng để nỗ lực. Trong hầu hết các trường hợp, nó không phải là.