for 与 foreach
常见的困惑是，这两种构造非常相似，并且两者可以互换，如下所示：
foreach (var c in collection)
{
DoSomething(c);
}
和：
for (var i = 0; i < collection.Count; i++)
{
DoSomething(collection[i]);
}
两个关键字都以相同的三个字母开头的事实并不意味着它们在语义上是相似的。这种混乱非常容易出错，特别是对于初学者。遍历一个集合并且对元素做一些事情foreach; for除非您真的知道自己在做什么，否则不必也不应将其用于此目的。
让我们看一个例子的问题。最后，您将找到用于收集结果的演示应用程序的完整代码。
在该示例中，我们在遇到“波士顿”之前从数据库中加载了一些数据，更确切地说是从Adventure Works中按名称排序的城市。使用以下SQL查询：
select distinct [City] from [Person].[Address] order by [City]
数据通过ListCities()返回的方法加载IEnumerable<string>。这里是什么foreach样子：
foreach (var city in Program.ListCities())
{
Console.Write(city + " ");
if (city == "Boston")
{
break;
}
}
让我们用重写它for，假设两者都是可互换的：
var cities = Program.ListCities();
for (var i = 0; i < cities.Count(); i++)
{
var city = cities.ElementAt(i);
Console.Write(city + " ");
if (city == "Boston")
{
break;
}
}
两者返回相同的城市，但有很大的不同。
- 使用时
foreach，ListCities()被调用一次并产生47个项目。
- 使用时
for，ListCities()被调用94次，总共产生28153个项目。
发生了什么？
IEnumerable是懒惰的。这意味着它将仅在需要结果时进行工作。惰性评估是一个非常有用的概念，但有一些警告，包括容易错过需要结果的时刻的事实，特别是在多次使用结果的情况下。
在a的情况下，foreach仅请求一次结果。在for 上述错误编写的代码中实现的 a的情况下，请求结果94次，即47×2：
查询数据库94次而不是查询一次是很糟糕的，但不是最糟糕的事情。例如，想象一下，如果在select查询之前执行查询，并且该查询还在表中插入一行，将会发生什么情况。是的，我们希望for它将调用数据库2,147,483,647次，除非希望它之前崩溃了。
当然，我的代码是有偏见的。我故意使用的惰性，IEnumerable并以反复调用的方式编写它ListCities()。可以注意到，初学者永远不会那样做，因为：
可能大多数初学者只会将结果转换为ListCities()他们熟悉的内容，例如List<T>。
var cities = Program.ListCities();
var flushedCities = cities.ToList();
for (var i = 0; i < flushedCities.Count; i++)
{
var city = flushedCities[i];
Console.Write(city + " ");
if (city == "Boston")
{
break;
}
}
但是，此代码与foreach替代代码有很大不同。同样，它给出的结果相同，这一次该ListCities()方法只调用了一次，但是产生了575个项目，而使用时foreach，它只产生了47个项目。
差异来自ToList()导致从数据库加载所有数据的事实。尽管foreach仅要求“波士顿”之前的城市，但新的for要求检索所有城市并将其存储在内存中。使用575个短字符串，这可能并没有多大区别，但是如果我们只从包含数十亿条记录的表中检索几行呢？
那到底是foreach什么？
foreach更接近while循环。我以前使用的代码：
foreach (var city in Program.ListCities())
{
Console.Write(city + " ");
if (city == "Boston")
{
break;
}
}
可以简单地替换为：
using (var enumerator = Program.ListCities().GetEnumerator())
{
while (enumerator.MoveNext())
{
var city = enumerator.Current;
Console.Write(city + " ");
if (city == "Boston")
{
break;
}
}
}
两者产生相同的IL。两者具有相同的结果。两者都有相同的副作用。当然，这while可以用类似的infinite重写for，但是它甚至更长，并且容易出错。您可以自由选择更易读的内容。
要自己测试吗？这是完整的代码：
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Linq;
public class Program
{
private static int countCalls;
private static int countYieldReturns;
public static void Main()
{
Program.DisplayStatistics("for", Program.UseFor);
Program.DisplayStatistics("for with list", Program.UseForWithList);
Program.DisplayStatistics("while", Program.UseWhile);
Program.DisplayStatistics("foreach", Program.UseForEach);
Console.WriteLine("Press any key to continue...");
Console.ReadKey(true);
}
private static void DisplayStatistics(string name, Action action)
{
Console.WriteLine("--- " + name + " ---");
Program.countCalls = 0;
Program.countYieldReturns = 0;
var measureTime = Stopwatch.StartNew();
action();
measureTime.Stop();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("The data was called {0} time(s) and yielded {1} item(s) in {2} ms.", Program.countCalls, Program.countYieldReturns, measureTime.ElapsedMilliseconds);
Console.WriteLine();
}
private static void UseFor()
{
var cities = Program.ListCities();
for (var i = 0; i < cities.Count(); i++)
{
var city = cities.ElementAt(i);
Console.Write(city + " ");
if (city == "Boston")
{
break;
}
}
}
private static void UseForWithList()
{
var cities = Program.ListCities();
var flushedCities = cities.ToList();
for (var i = 0; i < flushedCities.Count; i++)
{
var city = flushedCities[i];
Console.Write(city + " ");
if (city == "Boston")
{
break;
}
}
}
private static void UseForEach()
{
foreach (var city in Program.ListCities())
{
Console.Write(city + " ");
if (city == "Boston")
{
break;
}
}
}
private static void UseWhile()
{
using (var enumerator = Program.ListCities().GetEnumerator())
{
while (enumerator.MoveNext())
{
var city = enumerator.Current;
Console.Write(city + " ");
if (city == "Boston")
{
break;
}
}
}
}
private static IEnumerable<string> ListCities()
{
Program.countCalls++;
using (var connection = new SqlConnection("Data Source=mframe;Initial Catalog=AdventureWorks;Integrated Security=True"))
{
connection.Open();
using (var command = new SqlCommand("select distinct [City] from [Person].[Address] order by [City]", connection))
{
using (var reader = command.ExecuteReader(CommandBehavior.SingleResult))
{
while (reader.Read())
{
Program.countYieldReturns++;
yield return reader["City"].ToString();
}
}
}
}
}
}
结果：
---代表----
Abingdon Albany Alexandria Alhambra [...]波恩·波尔多波士顿
该数据称为94次，共产生28153条。
---带有列表---
Abingdon Albany Alexandria Alhambra [...]波恩波尔多波士顿
该数据称为1次，产生了575项。
---同时---
阿宾登·奥尔巴尼·亚历山大·阿尔罕布拉[波恩·波尔多]波士顿
该数据称为1次，产生了47项。
--- foreach ---
阿宾登·奥尔巴尼·亚历山大·阿尔罕布拉[...]波恩·波尔多波士顿
该数据称为1次，产生了47项。
LINQ与传统方式
至于LINQ，您可能想学习函数式编程（FP）-不是C＃FP的东西，而是真正的FP语言，例如Haskell。功能语言具有表达和呈现代码的特定方式。在某些情况下，它优于非功能性范例。
众所周知，FP在处理列表（列表作为通用术语，与不相关List<T>）方面要优越得多。考虑到这一事实，当涉及到列表时，以更实用的方式表达C＃代码的能力相当不错。
如果您不确定，请在我之前对这个问题的回答中比较以功能和非功能方式编写的代码的可读性。