二维数组未实现IEnumerable<T>，为何foreach能识别其元素类型？

核心原因：数组的接口实现差异与foreach的特殊处理 #

• 一维数组T[]直接实现了IEnumerable<T>，因此可以直接赋值给IEnumerable<T>类型变量。
• 多维数组T[,]仅实现了非泛型的IEnumerable接口，并未实现泛型的IEnumerable<T>，所以无法直接转换为IEnumerable<T>。
• foreach循环并非完全依赖IEnumerable<T>接口：C#编译器对数组（包括多维数组）有专门的优化逻辑，会直接生成遍历数组元素的原生代码，跳过接口调用步骤，因此能直接推断出var的类型为T，无需装箱拆箱。

解决代码重复与性能问题的方案 #

方案1：提取公共逻辑到私有方法，用Span<T>统一处理 #

在.NET Core/.NET 5+环境下，多维数组可以通过MemoryMarshal转换为Span<T>，一维数组也能直接转Span<T>。将核心遍历逻辑抽到接受Span<T>的私有方法中，既能避免代码重复，又能保证最优性能：

public int Average(Foo[] values)
{
    return AverageCore(values.AsSpan());
}

public int Average(Foo[,] values)
{
    // 将二维数组转换为Span<Foo>，无额外内存分配
    var span = MemoryMarshal.Cast<Foo[,], Foo>(values).AsSpan();
    return AverageCore(span);
}

// 公共核心逻辑，处理Span<Foo>，性能与直接遍历数组一致
private int AverageCore(Span<Foo> values)
{
    // 大量代码
    foreach (var foo in values)
    {
        var bar = foo.GetBar();
        // 大量代码
    }
    // 大量代码
    return result;
}

Span<T>是栈分配类型，遍历过程无堆内存开销，完全满足性能优化需求。

方案2：编写无分配的扩展方法，将二维数组转为IEnumerable<T> #

如果需要保留IEnumerable<Foo>的方法签名，可以实现一个基于值类型枚举器的扩展方法，避免迭代器状态机的堆分配：

public static class MultiDimensionalArrayExtensions
{
    public static IEnumerable<Foo> AsEnumerableNoAlloc(this Foo[,] array)
    {
        return new MultiDimensionalFooEnumerable(array);
    }

    private class MultiDimensionalFooEnumerable : IEnumerable<Foo>
    {
        private readonly Foo[,] _array;

        public MultiDimensionalFooEnumerable(Foo[,] array)
        {
            _array = array;
        }

        public IEnumerator<Foo> GetEnumerator()
        {
            return new MultiDimensionalFooEnumerator(_array);
        }

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }

    private struct MultiDimensionalFooEnumerator : IEnumerator<Foo>
    {
        private readonly Foo[,] _array;
        private int _row;
        private int _col;

        public MultiDimensionalFooEnumerator(Foo[,] array)
        {
            _array = array;
            _row = -1;
            _col = 0;
            Current = default!;
        }

        public Foo Current { get; private set; }

        object? IEnumerator.Current => Current;

        public bool MoveNext()
        {
            _col++;
            if (_col >= _array.GetLength(1))
            {
                _col = 0;
                _row++;
                if (_row >= _array.GetLength(0))
                    return false;
            }
            Current = _array[_row, _col];
            return true;
        }

        public void Reset()
        {
            _row = -1;
            _col = 0;
            Current = default!;
        }

        public void Dispose() { }
    }
}

调用方式：

Foo[,] array2d = /**/;
Average(array2d.AsEnumerableNoAlloc());

该扩展方法的枚举器为值类型，遍历过程无堆内存分配，性能接近直接遍历二维数组。

方案3：强制类型转换（不推荐） #

虽然可以通过Unsafe.As<Foo[,], IEnumerable<Foo>>(array2d)强制转换，但这属于未定义行为，依赖CLR内部实现，可能在未来版本中失效，因此不建议使用。

内容的提问来源于stack exchange，提问作者hypehuman