在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
(编辑)
除了可读性之外，我对事实和数据真的很感兴趣。在某些应用中，最后一英里的性能优化确实很重要。
当前回答
一种强大而精确的测量时间的方法是使用BenchmarkDotNet库。
在下面的示例中，我在for/foreach上对1,000,000,000个整数记录进行了循环，并使用BenchmarkDotNet进行了测量:
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
public class Program
{
public static void Main()
{
BenchmarkRunner.Run<LoopsBenchmarks>();
}
}
[MemoryDiagnoser]
public class LoopsBenchmarks
{
private List<int> arr = Enumerable.Range(1, 1_000_000_000).ToList();
[Benchmark]
public void For()
{
for (int i = 0; i < arr.Count; i++)
{
int item = arr[i];
}
}
[Benchmark]
public void Foreach()
{
foreach (int item in arr)
{
}
}
}
结果如下:
结论
在上面的例子中，我们可以看到for循环比foreach循环略快。我们还可以看到两者使用相同的内存分配。
其他回答
两者之间不太可能有巨大的性能差异。与往常一样，当面对“哪个更快?”的问题时，您应该始终认为“我可以测量这个”。
在循环体中编写两个做相同事情的循环，执行并计时，并查看速度的差异。使用一个几乎为空的主体和一个与您实际要做的类似的循环主体来执行此操作。还可以尝试使用您正在使用的集合类型，因为不同类型的集合可能具有不同的性能特征。
我的猜测是，在99%的情况下，它可能并不重要，所以为什么要选择更快的，而不是最合适的(最容易理解/维护)?
internal static void Test()
{
int LOOP_LENGTH = 10000000;
Random random = new Random((int)DateTime.Now.ToFileTime());
{
Dictionary<int, int> dict = new Dictionary<int, int>();
long first_memory = GC.GetTotalMemory(true);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i < 64; i++)
{
dict.Add(i, i);
}
for (int i = 0; i < LOOP_LENGTH; i++)
{
for (int k = 0; k < dict.Count; k++)
{
if (dict[k] > 1000000) Console.WriteLine("Test");
}
}
stopWatch.Stop();
var last_memory = GC.GetTotalMemory(true);
Console.WriteLine($"Dictionary for T:{stopWatch.Elapsed.TotalSeconds}s\t M:{last_memory - first_memory}");
GC.Collect();
}
{
Dictionary<int, int> dict = new Dictionary<int, int>();
long first_memory = GC.GetTotalMemory(true);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i < 64; i++)
{
dict.Add(i, i);
}
for (int i = 0; i < LOOP_LENGTH; i++)
{
foreach (var item in dict)
{
if (item.Value > 1000000) Console.WriteLine("Test");
}
}
stopWatch.Stop();
var last_memory = GC.GetTotalMemory(true);
Console.WriteLine($"Dictionary foreach T:{stopWatch.Elapsed.TotalSeconds}s\t M:{last_memory - first_memory}");
GC.Collect();
}
{
Dictionary<int, int> dict = new Dictionary<int, int>();
long first_memory = GC.GetTotalMemory(true);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i < 64; i++)
{
dict.Add(i, i);
}
for (int i = 0; i < LOOP_LENGTH; i++)
{
foreach (var item in dict.Values)
{
if (item > 1000000) Console.WriteLine("Test");
}
}
stopWatch.Stop();
var last_memory = GC.GetTotalMemory(true);
Console.WriteLine($"Dictionary foreach values T:{stopWatch.Elapsed.TotalSeconds}s\t M:{last_memory - first_memory}");
GC.Collect();
}
{
List<int> dict = new List<int>();
long first_memory = GC.GetTotalMemory(true);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i < 64; i++)
{
dict.Add(i);
}
for (int i = 0; i < LOOP_LENGTH; i++)
{
for (int k = 0; k < dict.Count; k++)
{
if (dict[k] > 1000000) Console.WriteLine("Test");
}
}
stopWatch.Stop();
var last_memory = GC.GetTotalMemory(true);
Console.WriteLine($"list for T:{stopWatch.Elapsed.TotalSeconds}s\t M:{last_memory - first_memory}");
GC.Collect();
}
{
List<int> dict = new List<int>();
long first_memory = GC.GetTotalMemory(true);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i < 64; i++)
{
dict.Add(i);
}
for (int i = 0; i < LOOP_LENGTH; i++)
{
foreach (var item in dict)
{
if (item > 1000000) Console.WriteLine("Test");
}
}
stopWatch.Stop();
var last_memory = GC.GetTotalMemory(true);
Console.WriteLine($"list foreach T:{stopWatch.Elapsed.TotalSeconds}s\t M:{last_memory - first_memory}");
GC.Collect();
}
}
T:10.1957728s M:2080的字典 字典T:10.5900586 M:1952 字典foreach值T:3.8294776s M:2088 T:3.7981471s M:320 T:4.4861377s M:648
我建议你读读这篇文章，看看具体的答案。本文的结论是，使用for循环通常比foreach循环更好更快。
当你遍历常见的结构如数组、列表等时，for-和foreach-循环的速度差异很小，并且在集合上执行LINQ查询几乎总是稍微慢一些，尽管它写得更好!正如其他海报上说的那样，追求表现力而不是多出一毫秒的性能。
到目前为止还没有说的是，当编译foreach循环时，编译器会根据它迭代的集合对它进行优化。这意味着当你不确定使用哪个循环时，你应该使用foreach循环——它会在编译时为你生成最好的循环。它的可读性也更强。
foreach循环的另一个关键优势是，如果你的集合实现发生了变化(例如，从int数组到List<int>)，那么你的foreach循环将不需要任何代码更改:
foreach (int i in myCollection)
不管你的集合是什么类型，上面的都是一样的，而在你的for循环中，如果你把myCollection从数组改变为List，下面的将不会构建:
for (int i = 0; i < myCollection.Length, i++)
