首页 > 代码库 > foreach vs List<T>.Foreach

foreach vs List<T>.Foreach

2024-07-28 19:07:57   227人阅读

今天当我用foreach循环迭代一个List<int>时，我发现我变得更加了解性能问题，而以前我会去迭代一个int的ArrayList，我对此感到一点沾沾自喜。得益于泛型所带来的好处，C#编译器可以用System.Collections.Generics.IEnumerator<int>避免大量的装箱(boxing)操作，相比使用老式的System.Collections.IEnumerator。我开始想：这真的是最快的方式吗？在经过一番调查研究后，这（foreach）还不是最快的方式。

.NET 2.0发布了一些小的nuggets，可以使得我们更容易地编写代码。我最喜欢的当属Array和List<T>说添加的额外方法，这些方法接受Action<T>，Converter<TInput, TOutput>和Predicate<T>作为泛型delegate。事实上，我对这些东西还是很着迷的。当这些方法与匿名方法和lambda表达式结合使用时将发挥巨大作用。

我感兴趣的一个特别的方法是List<T>.ForEach(Action<T>)。我很好奇，ForEach调用比一个标准的foreach-loop要来的快还是慢，还是一样快？考虑如下代码：

 

[csharp] view plaincopyprint?
 
  1. long Sum(List<int> intList)  
  2. {  
  3.     long result = 0;  
  4.     foreach (int i in intList)  
  5.         result += i;  
  6.     return result;  
  7. }  

C#编译器会为上面的代码生成类似如下的伪代码：

 

 

[csharp] view plaincopyprint?
 
  1. long Sum(List<int> intList)  
  2. {  
  3.   long result = 0;  
  4.   List<T>.Enumerator enumerator = intList.GetEnumerator();  
  5.   try  
  6.   {  
  7.     while (enumerator.MoveNext())  
  8.     {  
  9.       int i = enumerator.Current;  
  10.       result += i;  
  11.     }  
  12.   }  
  13.   finally  
  14.   {  
  15.     enumerator.Dispose();  
  16.   }  
  17.   return result;  
  18. }  

事实上，C#编译器为每次迭代生成了2个方法调用：IEnumerator<T>.MoveNext()和IEnumerator<T>.Current。List<T>.Enumerator结构（用IEnumerator实现）允许编译器生成call IL指令而不是callvirt ，这会有一点性能提升。相反，考虑如下代码：

 

 

[csharp] view plaincopyprint?
 
  1. long Sum(List<int> intList)  
  2. {  
  3.   long result = 0;  
  4.   intList.ForEach(delegate(int i) { result += i; });  
  5.   result result;  
  6. }  

或者，等价的lambda表达式：

 

 

[csharp] view plaincopyprint?
 
  1. long Sum(List<int> intList)  
  2. {  
  3.   long result = 0;  
  4.   intList.ForEach(i => result += i);  
  5.   return result;  
  6. }  

使用List<T>.ForEach只会导致每次迭代中使用1个方法调用：无论你提供了什么样的Action<T>委托。这会被用callvirt IL指令调用，但是2个call指令（一个MoveNext和一个Current）应该比一个callvirt指令慢。所以我期望是List<T>.ForEach会更快一个（比foreach）。

 

有了这些假设，我创建了一个小的console程序，用以下4中不同的方法来迭代一个List<int>实例，并求和：

 

  1. 用for-loop迭代：for (int i = 0; i < List<int>.Count; ++i)
  2. 用for-loop，但是不调用Count：for (int i = 0; i < NUM_ITEMS; ++i)
  3. 用foreach-loop：foreach (int i in List<T>)
  4. 用List<int>.ForEach来迭代：List<int>.ForEach(delegate(int i) { result += i; })

 

首先，测试没有开启优化情况：


这些结果令人难以想象。结果，当不开启编译器优化，List<int>.ForEach比一个for-loop还要快！foreach和for-loop几乎同样快。所以如果你在没有开启优化的情况下编译你的程序，List<int>.ForEach是最快的方式。

接下来，我开启编译器优化来获得一个比较真实的结果：

看这些数字，编译器对for-loop优化超过50%而印象深刻。foreach-loop同样也获得了大约20%的提升。List<int>.ForEach没有获得很多的优化，但是需要注意，ForEach依然比foreach-loop来的快很多。List<T>.ForEach比标准的foreach-loop来的快。

注意，这些测试在一台Dell Inspiron 9400的笔记本上运行，CPU是Core Duo T2400，2GB内存。如果你想要自己测试一些结果，你可以下载ForEachTest.zip(3.82KB)。

一幅图片胜过千言万语，我生成了一个图表来展示不同迭代之间的速度差异。图表中显示了5个不同的取样，分别从10,000,000到50,000,000次迭代。

未启编译器优化：

开启编译器优化：

最终观点：虽然ForEach方法在迭代List<T>是非常快，但是碰到数组时就不一样了。一维数组没有ForEach方法，而且用ForEach比用foreach来的慢很多。原因是编译器没有为foreach 迭代数组生成IEnumerator<T>代码。用foreach来迭代数组，不会有方法调用，但是Array.ForEach还是会为每次迭代调用一次委托（一个callvirt调用？）。

foreach vs List<T>.Foreach


联系
我们