从数组中获取通用枚举器

Question

在 C# 中，如何从给定数组获取通用枚举器？

在下面的代码中，MyArray 是 MyType 对象的数组。 我想以所示的方式获取 MyIEnumerator， 但似乎我获得了一个空的枚举器（尽管我已经确认 MyArray.Length > 0）。

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

Answer 1

适用于 2.0+：

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

适用于 3.5+（花哨的 LINQy，效率稍低）：

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

Answer 2

您可以自己决定强制转换是否丑陋到足以保证进行无关的库调用：

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

为了完整性，还应该注意以下内容是不正确的 - 并且会在运行时崩溃 - 因为 T[] 选择非通用IEnumerable接口作为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>
}

神秘的是，为什么 SZGenericArrayEnumerator 不继承 SZArrayEnumerator（当前标记为“密封”的内部类），因为这将允许 (协变) 默认返回通用枚举器？

Answer 3

由于我不喜欢选角，所以更新一下：

your_array.AsEnumerable().GetEnumerator();

Answer 4

为了使其尽可能干净，我喜欢让编译器完成所有工作。 没有强制转换（所以它实际上是类型安全的）。 不使用第三方库 (System.Linq)（无运行时开销）。

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

// 使用代码：

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

这利用了一些编译器的魔力来保持一切干净。

另一点需要注意的是，我的答案是唯一会进行编译时检查的答案。

对于任何其他解决方案，如果“arr”的类型发生更改，则调用代码将编译，并在运行时失败，从而导致运行时错误。

我的答案将导致代码无法编译，因此我在代码中产生错误的机会较小，因为它会向我发出信号，表明我使用了错误的类型。

Answer 5

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

    IEnumerable<MyType> enumerable = arr;

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

    foreach (MyType item in enumerable)
    {

    }

Answer 6

YourArray.OfType().GetEnumerator();

可能会表现得更好一些，因为它只需要检查类型，而不需要强制转换。

Answer 7

当然，您可以做的就是为数组实现您自己的通用枚举器。

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

这或多或少等于 SZGenericArrayEnumerator的 .NET 实现。 正如格伦·斯莱登所提到的。 当然，只有在值得付出努力的情况下才应该这样做。 大多数情况下并非如此。

Answer 8

由于@Mehrdad Afshari 回答我为此创建了扩展方法：

public static IEnumerator<T> GetEnumerator<T>(this T[] array) {
    return (IEnumerator<T>)array.GetEnumerator();
}

所以你可以像这样实现 IEnumerable ：

public class MulticoloredLine : IEnumerable<ColoredLine> {
    private ColoredLine[] coloredLines;    

    #region IEnumerable<ColoredLine>
    public IEnumerator<ColoredLine> GetEnumerator() => 
    coloredLines.GetEnumerator<ColoredLine>();
    IEnumerator IEnumerable.GetEnumerator() => coloredLines.GetEnumerator();
    #endregion
}