在 C# 中，如何从给定数组中获取泛型枚举数？
在下面的代码中，MyArray 是 MyType 对象的数组。我想以所示的方式获得MyIEnumerator，
但似乎我得到了一个空的枚举器（虽然我已经确认MyArray.Length > 0）。
MyType[] MyArray = ... ;
IEnumerator<MyType> MyIEnumerator = MyArray.GetEnumerator() as IEnumerator<MyType>;
【问题讨论】：
标签： c# arrays generics ienumerator
适用于 2.0+：
((IEnumerable<MyType>)myArray).GetEnumerator()
适用于 3.5+（花哨的 LINQy，效率稍低）：
myArray.Cast<MyType>().GetEnumerator() // returns IEnumerator<MyType>
【讨论】：
LINQ/Cast 具有完全不同的运行时行为，因为数组的每个元素 将通过一组额外的MoveNext 和Current 枚举器往返，如果数组很大，这可能会影响性能。无论如何，通过首先获得适当的枚举器（即使用我的答案中显示的两种方法之一），可以完全轻松地避免该问题。
myArray.Cast<MyType>().GetEnumerator()，即使对于很小的数组，它也可能会显着减慢您的速度。
您可以自己决定强制转换是否丑到足以保证一个无关的库调用：
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[] 选择 non-generic 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<T> 不从SZArrayEnumerator 继承——一个当前标记为“密封”的内部类——因为这将允许默认返回（协变）泛型枚举数？
【讨论】：
((IEnumerable<int>)arr) 中使用了额外的括号，但在(IEnumerator<int>)arr 中只使用了一组括号，这是有原因的吗？
as 的 IL 会比强制转换更优化吗？
as 将各自直接映射到它们自己的特定 IL 指令 -- castclass 与 isinst 相比。尽管从定义上看，“as”直觉上似乎在做更多存在的“工作”，但这两者之间的实际性能差异可能在任何情况下都无法衡量。
由于我不喜欢选角，所以稍微更新一下：
your_array.AsEnumerable().GetEnumerator();
【讨论】：
your_array.AsEnumerable() 将不会首先编译，因为AsEnumerable() 只能用于实现IEnumerable 的类型的实例。
为了让它尽可能干净，我喜欢让编译器完成所有工作。没有强制转换（因此它实际上是类型安全的）。不使用第三方库 (System.Linq)（无运行时开销）。
public static IEnumerable<T> GetEnumerable<T>(this T[] arr)
{
return arr;
}
// 并使用代码：
String[] arr = new String[0];
arr.GetEnumerable().GetEnumerator()
这利用了一些保持一切干净的编译器魔法。
需要注意的另一点是我的答案是唯一会进行编译时检查的答案。
对于任何其他解决方案，如果“arr”的类型发生更改，则调用代码将编译，并在运行时失败，从而导致运行时错误。
我的回答将导致代码无法编译，因此我在代码中出现错误的可能性较小，因为它会向我表明我使用了错误的类型。
【讨论】：
Foo[] 实现了IEnumerable<Foo>，但是如果它发生了变化，它将不会在编译时被检测到。显式转换永远不是编译时证明。相反，分配/返回数组作为 IEnumerablevar foo = (int)new object()。它编译得很好并在运行时崩溃。
YourArray.OfType().GetEnumerator();
性能可能会好一点，因为它只需要检查类型，而不是强制转换。
【讨论】：
OfType<..type..>()时明确指定类型——至少在我的double[][]的情况下
MyType[] arr = { new MyType(), new MyType(), new MyType() };
IEnumerable<MyType> enumerable = arr;
IEnumerator<MyType> en = enumerable.GetEnumerator();
foreach (MyType item in enumerable)
{
}
【讨论】：
当然，您可以做的只是为数组实现自己的通用枚举器。
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. */}
}
}
这或多或少等于 Glenn Slayden 提到的 SZGenericArrayEnumerator
【讨论】：