在c# / VB.NET/。哪个循环运行得更快，for还是foreach?
自从很久以前我读到for循环比foreach循环工作得快，我就认为它适用于所有集合、泛型集合、所有数组等。
我搜索了谷歌，找到了几篇文章，但大多数都是不确定的(阅读文章评论)，而且是开放式的。
理想的情况是列出每种情况以及最佳解决方案。
例如(这只是一个例子):
用于迭代1000+的数组 字符串- for比foreach好 对于迭代IList(非泛型)字符串- foreach更好 比
在网上找到了一些相同的参考资料:
由Emmanuel Schanzer撰写的原创文章 CodeProject FOREACH Vs. FOR 博客——去博客还是不去博客，这是个问题 ASP。NET论坛- NET 1.1 c# for vs foreach
(编辑)
除了可读性之外，我对事实和数据真的很感兴趣。在某些应用中，最后一英里的性能优化确实很重要。
当前回答
Patrick Smacchia上个月写了一篇博客，总结如下:
List上的for循环比foreach便宜2倍多一点 循环列表。 在array上循环比在List上循环便宜2倍左右。 因此，使用for对数组进行循环要便宜5倍 而不是使用foreach在List上循环 (我相信，这是我们都在做的事情)。
其他回答
我的猜测是，在99%的情况下，它可能并不重要，所以为什么要选择更快的，而不是最合适的(最容易理解/维护)?
For有更简单的逻辑实现，所以它比foreach快。
这可以节省你:
public IEnumerator<int> For(int start, int end, int step) {
int n = start;
while (n <= end) {
yield n;
n += step;
}
}
Use:
foreach (int n in For(1, 200, 4)) {
Console.WriteLine(n);
}
为了获得更大的胜利，你可以把三名代表作为参数。
我发现foreach循环迭代列表更快。下面是我的测试结果。在下面的代码中，我分别迭代一个大小为100、10000和100000的数组，使用for和foreach循环来测量时间。
private static void MeasureTime()
{
var array = new int[10000];
var list = array.ToList();
Console.WriteLine("Array size: {0}", array.Length);
Console.WriteLine("Array For loop ......");
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i < array.Length; i++)
{
Thread.Sleep(1);
}
stopWatch.Stop();
Console.WriteLine("Time take to run the for loop is {0} millisecond", stopWatch.ElapsedMilliseconds);
Console.WriteLine(" ");
Console.WriteLine("Array Foreach loop ......");
var stopWatch1 = Stopwatch.StartNew();
foreach (var item in array)
{
Thread.Sleep(1);
}
stopWatch1.Stop();
Console.WriteLine("Time take to run the foreach loop is {0} millisecond", stopWatch1.ElapsedMilliseconds);
Console.WriteLine(" ");
Console.WriteLine("List For loop ......");
var stopWatch2 = Stopwatch.StartNew();
for (int i = 0; i < list.Count; i++)
{
Thread.Sleep(1);
}
stopWatch2.Stop();
Console.WriteLine("Time take to run the for loop is {0} millisecond", stopWatch2.ElapsedMilliseconds);
Console.WriteLine(" ");
Console.WriteLine("List Foreach loop ......");
var stopWatch3 = Stopwatch.StartNew();
foreach (var item in list)
{
Thread.Sleep(1);
}
stopWatch3.Stop();
Console.WriteLine("Time take to run the foreach loop is {0} millisecond", stopWatch3.ElapsedMilliseconds);
}
更新
在@jgauffin建议后，我使用了@johnskeet代码，发现使用数组的for循环比下面的更快，
Foreach循环与数组。 For带列表的循环。 Foreach循环与列表。
请看下面我的测试结果和代码，
private static void MeasureNewTime()
{
var data = new double[Size];
var rng = new Random();
for (int i = 0; i < data.Length; i++)
{
data[i] = rng.NextDouble();
}
Console.WriteLine("Lenght of array: {0}", data.Length);
Console.WriteLine("No. of iteration: {0}", Iterations);
Console.WriteLine(" ");
double correctSum = data.Sum();
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < Iterations; i++)
{
double sum = 0;
for (int j = 0; j < data.Length; j++)
{
sum += data[j];
}
if (Math.Abs(sum - correctSum) > 0.1)
{
Console.WriteLine("Summation failed");
return;
}
}
sw.Stop();
Console.WriteLine("For loop with Array: {0}", sw.ElapsedMilliseconds);
sw = Stopwatch.StartNew();
for (var i = 0; i < Iterations; i++)
{
double sum = 0;
foreach (double d in data)
{
sum += d;
}
if (Math.Abs(sum - correctSum) > 0.1)
{
Console.WriteLine("Summation failed");
return;
}
}
sw.Stop();
Console.WriteLine("Foreach loop with Array: {0}", sw.ElapsedMilliseconds);
Console.WriteLine(" ");
var dataList = data.ToList();
sw = Stopwatch.StartNew();
for (int i = 0; i < Iterations; i++)
{
double sum = 0;
for (int j = 0; j < dataList.Count; j++)
{
sum += data[j];
}
if (Math.Abs(sum - correctSum) > 0.1)
{
Console.WriteLine("Summation failed");
return;
}
}
sw.Stop();
Console.WriteLine("For loop with List: {0}", sw.ElapsedMilliseconds);
sw = Stopwatch.StartNew();
for (int i = 0; i < Iterations; i++)
{
double sum = 0;
foreach (double d in dataList)
{
sum += d;
}
if (Math.Abs(sum - correctSum) > 0.1)
{
Console.WriteLine("Summation failed");
return;
}
}
sw.Stop();
Console.WriteLine("Foreach loop with List: {0}", sw.ElapsedMilliseconds);
}
这和大多数“哪个更快”的问题有相同的两个答案:
1)如果你不测量，你就不知道。
2)(因为…)视情况而定。
这取决于“MoveNext()”方法的代价，相对于“this[int index]”方法的代价，对于你要迭代的IEnumerable的类型(或类型)。
“foreach”关键字是一系列操作的简写——它在IEnumerable上调用GetEnumerator()一次，每次迭代调用MoveNext()一次，它做一些类型检查，等等。最可能影响性能度量的是MoveNext()的成本，因为它被调用了O(N)次。可能便宜，但也可能不便宜。
“for”关键字看起来更容易预测，但在大多数“for”循环中，你会发现类似“collection[index]”这样的东西。这看起来像是一个简单的数组索引操作，但它实际上是一个方法调用，其开销完全取决于迭代的集合的性质。可能便宜，但也可能不便宜。
如果集合的底层结构本质上是一个链表，MoveNext是非常便宜的，但是索引器可能有O(N)成本，使得“for”循环的真正成本为O(N*N)。
