实现数组中项的总和非常简单。我认为大多数开发人员会以这种方式实现它：

static int Sum(int[] array)
{var sum = 0;for (var index = 0; index < array.Length; index++)sum += array[index];return sum;
}

        C# 中实际上有一个更简单的替代方法：

static int Sum(int[] array)
{var sum = 0;foreach (var item in array)sum += item;return sum;
}

        另一种替代方法是使用 LINQ 提供的操作。它可以应用于任何可枚举项，包括数组。Sum()

        那么，这三者在性能方面如何公平呢？

        该基准测试比较了 .NET 10、1 和 000 上大小为 6 和 7.8 的阵列的性能。int

        您可以看到，使用循环 比使用循环快 30% 左右 。foreachfor

        在最新的 .NET 版本中，LINQ 实现有了很大的改进。它在 .NET 6 中要慢得多，但在 .NET 7 中要慢得多，对于 .NET 8 中的大型数组来说要快得多。

三、foreachfor

        怎么能比循环更快？foreachfor和循环都是循环的语法糖。当在数组上使用这些代码时，编译器实际上会生成非常相似的代码。forforeachwhile

        你可以在SharpLab中看到以下代码：

var array = new[] {0, 1, 2, 3, 4, 5 };Console.WriteLine(Sum_For());
Console.WriteLine(Sum_ForEach());int Sum_For()
{var sum = 0;for (var index = 0; index < array.Length; index++)sum += array[index];return sum;                     
}int Sum_ForEach()
{var sum = 0;foreach (var item in array)sum += item;return sum;                     
}

        编译器生成以下内容：

[CompilerGenerated]
private static int <<Main>$>g__Sum_For|0_0(ref <>c__DisplayClass0_0 P_0)
{int num = 0;int num2 = 0;while (num2 < P_0.array.Length){num += P_0.array[num2];num2++;}return num;
}[CompilerGenerated]
private static int <<Main>$>g__Sum_ForEach|0_1(ref <>c__DisplayClass0_0 P_0)
{int num = 0;int[] array = P_0.array; // copy array referenceint num2 = 0;while (num2 < array.Length){int num3 = array[num2];num += num3;num2++;}return num;
}

        代码非常相似，但请注意，添加了对数组的引用作为局部变量。这允许 JIT 编译器删除边界检查，从而使迭代速度更快。检查生成的程序集的差异：foreach

Program.<<Main>$>g__Sum_For|0_0(<>c__DisplayClass0_0 ByRef)L0000: sub rsp, 0x28L0004: xor eax, eaxL0006: xor edx, edxL0008: mov rcx, [rcx]L000b: cmp dword ptr [rcx+8], 0L000f: jle short L0038L0011: nop [rax]L0018: nop [rax+rax]L0020: mov r8, rcxL0023: cmp edx, [r8+8]L0027: jae short L003dL0029: mov r9d, edxL002c: add eax, [r8+r9*4+0x10]L0031: inc edxL0033: cmp [rcx+8], edxL0036: jg short L0020L0038: add rsp, 0x28L003c: retL003d: call 0x000002e975d100fcL0042: int3Program.<<Main>$>g__Sum_ForEach|0_1(<>c__DisplayClass0_0 ByRef)L0000: xor eax, eaxL0002: mov rdx, [rcx]L0005: xor ecx, ecxL0007: mov r8d, [rdx+8]L000b: test r8d, r8dL000e: jle short L001fL0010: mov r9d, ecxL0013: add eax, [rdx+r9*4+0x10]L0018: inc ecxL001a: cmp r8d, ecxL001d: jg short L0010L001f: ret

        这导致基准测试中的性能得到改善。

        请注意，在 SharpLab 中，数组已经是一个局部变量，不会生成副本。在这种情况下，性能是等效的。

四、对数组进行切片

        有时我们可能只想迭代数组的一部分。再一次，我认为大多数开发人员会实现以下内容：

static int Sum(int[] source, int start, int length)
{var sum = 0;for (var index = start; index < start + length; index++)sum += source[index];return sum;        
}

        这可以通过使用 Span.Slice（） 方法轻松转换为 foreach：

static int Sum(int[] source, int start, int length)  => Sum(source.AsSpan().Slice(start, length));static int Sum(ReadOnlySpan<int> source)
{var sum = 0;foreach (var item in source)sum += item;return sum;
}

        那么，这些展会在表现方面如何呢？

        在数组的一部分上使用也比使用循环好 20% 左右。foreachfor

五、LINQ

        检查 in 的源代码，对于 .NET 8 之前的 .NET 版本，您会发现它使用循环 。那么，如果使用 a 比 a 快，为什么在这种情况下它这么慢？Sum()System.Linqforeachforeachfor

        此实现是 类型的扩展方法。与 和 操作不同，当源在数组中时没有特殊情况。编译器将此实现转换为如下所示的内容：Sum()IEnumerable<int>Count()Where()Sum()

static int Sum(this IEnumerable<int> source)
{var sum = 0;IEnumerator<int> enumerator = source.GetEnumerator();try{while(enumerator.MoveNext())sum += enumerator.Current;}finally{enumerator?.Dispose()}return sum;
}

        此代码存在多个性能问题：

• GetEnumerator()返回。这意味着枚举器是引用类型，这意味着它必须在堆上分配，从而增加垃圾回收器的压力。IEnumerator<T>
• IEnumerator<T>来自。然后，它需要 来释放枚举器，因此无法内联此方法。IDisposabletry/finally
• 对 的迭代需要调用方法和属性。由于枚举器是引用类型，因此这些调用是虚拟的。IEnumerable<T>MoveNext()Current

        所有这些都使数组的枚举速度慢得多。

注意：请查看我的另一篇文章“值类型枚举器的性能与引用类型枚举器的性能”，以了解这两种类型的枚举器之间的性能差异。

.NET 8 的性能要好得多，因为它会在 源是数组或 .如果是 or 的数组或列表，它会通过使用 SIMD 进行更多优化，从而允许同时对多个项目求和。Sum()List<T>intlong

注意：请查看我的另一篇文章“.NET 中的单指令多数据 （SIMD）”，了解 SIMD 的工作原理以及如何在代码中使用。

六、结论

        数组的迭代是编译器可以执行代码优化的特例。的使用保证了这些优化的最佳条件。foreach

        将数组转换为 会使其迭代速度慢得多。IEnumerable<T>

        并非所有 LINQ 方法都针对数组的情况进行了优化。在 .NET 8 之前，最好使用 Sum（） 方法的自定义实现。