c# - 更快的枚举 : Leveraging Array Enumeration

Question

所以，我有一个类，里面有一个数组。目前，我枚举类项目的策略是使用代码 foreach (item x in classInstance.InsideArray) .我宁愿使用 foreach (item x in classInstance)并将数组设为私有(private)。我主要担心的是我真的需要避免任何缓慢的事情；该数组受到了很多打击(并且有几百个项目)。枚举此数组的成本很低，这一点至关重要。一种想法是让类实现 IEnumerable<item> ，但是InsideArray.getEnumerator()只给我一个非通用枚举器。我还尝试实现 IEnumerable界面。这有效但速度很慢，可能是由于装箱。

有没有办法在不影响性能的情况下使类本身可枚举？

普通代码:

//Class
public class Foo {
    //Stuff
    public Item[,] InsideArray {get; private set;}
}

//Iteration.  Shows up all over the place
foreach (Item x in classInstance.InsideArray)
{
    //doStuff
}

调整后，速度慢得多的代码:

//Class
public class Foo : IEnumerable {
    //Stuff
    private Item[,] InsideArray;
    System.Collections.IEnumerator System.Collections.IEnumerable GetEnumerator()
    {
        return InsideArray.GetEnumerator();
    }
}

//Iteration.  Shows up all over the place
foreach (Item x in classInstance)
{
    //doStuff
}

注意:为非泛型迭代器添加一个实现是可能的，而且比我的慢速解决方案更快，但它仍然比直接使用数组差一点。我希望有一种方法可以以某种方式告诉 C#，“嘿，当我要求你迭代这个对象时，迭代它的数组，同样快，”但显然这不太可能......至少从建议的答案来看到目前为止。

Answer 1

定制的迭代器可能会使其更快(编辑以返回已知类型):

Basic: 2468ms - -2049509440
Bespoke: 1087ms - -2049509440

(您可以直接将 ArrayIterator 用作 Foo 的 GetEnumerator - 本质上是从 ArrayEnumerator.GetEnumerator 复制代码；我的意思是表明类型化迭代器比接口(interface)更快)

附代码:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

class Foo
{
    public struct ArrayIterator<T> : IEnumerator<T>
    {
        private int x, y;
        private readonly int width, height;
        private T[,] data;
        public ArrayIterator(T[,] data)
        {
            this.data = data;
            this.width = data.GetLength(0);
            this.height = data.GetLength(1);
            x = y = 0;
        }
        public void Dispose() { data = null; }
        public bool MoveNext()
        {
            if (++x >= width)
            {
                x = 0;
                y++;
            }
            return y < height;
        }
        public void Reset() { x = y = 0; }
        public T Current { get { return data[x, y]; } }
        object IEnumerator.Current { get { return data[x, y]; } }
    }
    public sealed class ArrayEnumerator<T> : IEnumerable<T>
    {
        private readonly T[,] arr;
        public ArrayEnumerator(T[,] arr) { this.arr = arr; }

        public ArrayIterator<T> GetEnumerator()
        {
            return new ArrayIterator<T>(arr);
        }

        System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator()
        {
            return GetEnumerator();
        }
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

    }
    public int[,] data;

    public IEnumerable<int> Basic()
    {
        foreach (int i in data) yield return i;
    }
    public ArrayEnumerator<int> Bespoke()
    {
        return new ArrayEnumerator<int>(data);
    }
    public Foo()
    {
        data = new int[500, 500];
        for (int x = 0; x < 500; x++)
            for (int y = 0; y < 500; y++)
            {
                data[x, y] = x + y;
            }
    }
    static void Main()
    {
        Test(1); // for JIT
        Test(500); // for real
        Console.ReadKey(); // pause
    }
    static void Test(int count)
    {
        Foo foo = new Foo();
        int chk;
        Stopwatch watch = Stopwatch.StartNew();
        chk = 0;
        for (int i = 0; i < count; i++)
        {
            foreach (int j in foo.Basic())
            {
                chk += j;
            }
        }
        watch.Stop();
        Console.WriteLine("Basic: " + watch.ElapsedMilliseconds + "ms - " + chk);

        watch = Stopwatch.StartNew();
        chk = 0;
        for (int i = 0; i < count; i++)
        {
            foreach (int j in foo.Bespoke())
            {
                chk += j;
            }
        }
        watch.Stop();
        Console.WriteLine("Bespoke: " + watch.ElapsedMilliseconds + "ms - " + chk);
    }
}