Question

我注意到迭代了一个原始集合（T []）的性能损失，该集合已被强制转换为通用接口集合（IList或IEnumberable）。

例如：

    private static int Sum(int[] array)
    {
        int sum = 0;

        foreach (int i in array)
            sum += i;

        return sum;
    }

上面的代码执行速度明显快于下面的代码，其中参数更改为类型IList（或IEnumerable）：

    private static int Sum(IList<int> array)
    {
        int sum = 0;

        foreach (int i in array)
            sum += i;

        return sum;
    }

如果传递的对象是原始数组，并且我尝试将循环更改为for循环而不是foreach循环，则仍会出现性能损失。

我可以通过编码来解决性能问题：

    private static int Sum(IList<int> array)
    {
        int sum = 0;

        if( array is int[] )
            foreach (int i in (int[])array)
                sum += i;
        else
            foreach (int i in array)
                sum += i;

        return sum;
    }

有更优雅的方法来解决这个问题吗？谢谢你的时间。

编辑：我的基准代码：

    static void Main(string[] args)
    {
        int[] values = Enumerable.Range(0, 10000000).ToArray<int>();
        Stopwatch sw = new Stopwatch();

        sw.Start();
        Sum(values);
        //Sum((IList<int>)values);
        sw.Stop();

        Console.WriteLine("Elasped: {0} ms", sw.ElapsedMilliseconds);
        Console.Read();
    }

Answer 1

如果此方法对性能至关重要，最好的办法是以Sum作为参数为int[]创建重载。 CLR的JIT可以检测 foreach 样式的数组迭代，并且可以跳过范围检查并直接处理每个元素。循环的每次迭代在x86上需要3-5条指令，只有一次内存查找。

使用IList时，JIT不了解底层集合的结构，最终使用IEnumerator<int>。循环的每次迭代都使用两个接口调用 - 一个用于Current，一个用于MoveNext（2-3个内存查找和每个调用）。这最有可能导致约20条非常昂贵的指令，而且你无能为力。

编辑：如果您对JIT从Release build 发出的实际机器代码感到好奇，而不附带调试器，请点击此处。

数组版本

            int s = 0;
00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  push        edi  
00000004  push        esi  
00000005  xor         esi,esi 
            foreach (int i in arg)
00000007  xor         edx,edx 
00000009  mov         edi,dword ptr [ecx+4] 
0000000c  test        edi,edi 
0000000e  jle         0000001B 
00000010  mov         eax,dword ptr [ecx+edx*4+8] 
                s += i;
00000014  add         esi,eax 
00000016  inc         edx  
            foreach (int i in arg)
00000017  cmp         edi,edx 
00000019  jg          00000010

IEnumerable version

            int s = 0;
00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  push        edi  
00000004  push        esi  
00000005  push        ebx  
00000006  sub         esp,1Ch 
00000009  mov         esi,ecx 
0000000b  lea         edi,[ebp-28h] 
0000000e  mov         ecx,6 
00000013  xor         eax,eax 
00000015  rep stos    dword ptr es:[edi] 
00000017  mov         ecx,esi 
00000019  xor         eax,eax 
0000001b  mov         dword ptr [ebp-18h],eax 
0000001e  xor         edx,edx 
00000020  mov         dword ptr [ebp-24h],edx 
            foreach (int i in arg)
00000023  call        dword ptr ds:[009E0010h] 
00000029  mov         dword ptr [ebp-28h],eax 
0000002c  mov         ecx,dword ptr [ebp-28h] 
0000002f  call        dword ptr ds:[009E0090h] 
00000035  test        eax,eax 
00000037  je          00000052 
00000039  mov         ecx,dword ptr [ebp-28h] 
0000003c  call        dword ptr ds:[009E0110h] 
                s += i;
00000042  add         dword ptr [ebp-24h],eax 
            foreach (int i in arg)
00000045  mov         ecx,dword ptr [ebp-28h] 
00000048  call        dword ptr ds:[009E0090h] 
0000004e  test        eax,eax 
00000050  jne         00000039 
00000052  mov         dword ptr [ebp-1Ch],0 
00000059  mov         dword ptr [ebp-18h],0FCh 
00000060  push        0F403BCh 
00000065  jmp         00000067 
00000067  cmp         dword ptr [ebp-28h],0 
0000006b  je          00000076 
0000006d  mov         ecx,dword ptr [ebp-28h] 
00000070  call        dword ptr ds:[009E0190h]

Answer 2

欢迎优化。事情并不总是很明显！

基本上，正如您所发现的，当编译器检测到某些类型的安全约束被证明为时，它可以在进行完全优化时发出极其高效的代码。在这里（如MagnatLU所示）我们看到知道你有一个数组允许对固定的大小做出各种假设，并且它允许直接访问内存（这也是它与如何集成的最大效率） CPU的内存预取代码，用于奖励速度）。当编译器没有证明它可以生成超快速代码时，它就可以安全地运行它。（这是正确的做法。）

作为一般性评论，在编码优化时（当使代码具有超级可读性和可维护性并不总是首要考虑时），您的变通方法代码非常简单。如果不让你的课程的API变得更复杂（不是胜利！），我真的不知道如何改进它。此外，只需在正文中添加注释，说明为什么要这样做就可以解决维护问题;事实上，这首先是代码中（非doc）注释的最佳用途之一。鉴于用例是大型数组（即，首先根据它进行优化是合理的），我会说你有一个很好的解决方案。

Answer 3

作为上述@ MagnatLU答案的替代方案，您可以使用for代替foreach并缓存列表的Count。与int[]相比仍有开销，但不是很多：使用我机器上的测试代码，IList<int>过载持续时间减少了约50％。

private static int Sum(IList<int> array)
{
    int sum = 0;

    int count = array.Count;
    for (int i = 0; i < count; i++)
        sum += array[i];

    return sum;
}

Iterating T []的开销转换为IList <t> </t>

3 个答案:

数组版本

IEnumerable version