你可以命名匿名委托:-)

你可以把第二个写成

someList.ForEach(s => s.ToUpper())

我更喜欢这个，而且节省了很多打字。

正如Joachim所说，并行性更容易应用于第二种形式。

List.ForEach()被认为更具功能性。

List.ForEach()表示你想做什么。Foreach(列表中的项目)也确切地说明了你想要如何完成它。这就剩下List了。ForEach可以自由更改未来如何部分的实现。例如，一个假设的。net未来版本可能总是运行List。在并行的情况下，假设此时每个人都有一些cpu核心通常处于空闲状态。

另一方面，foreach (list中的项)让您对循环有更多的控制。例如，您知道项目将以某种顺序进行迭代，如果项目满足某些条件，则很容易在中间中断。

---

关于这个问题的一些最新评论可在此查阅:

https://stackoverflow.com/a/529197/3043

我知道有两件事让他们不一样。去我!

首先，有一个典型的错误，即为列表中的每个项目创建一个委托。如果你使用foreach关键字，你所有的委托最终都会指向列表的最后一项:

    // A list of actions to execute later
    List<Action> actions = new List<Action>();

    // Numbers 0 to 9
    List<int> numbers = Enumerable.Range(0, 10).ToList();

    // Store an action that prints each number (WRONG!)
    foreach (int number in numbers)
        actions.Add(() => Console.WriteLine(number));

    // Run the actions, we actually print 10 copies of "9"
    foreach (Action action in actions)
        action();

    // So try again
    actions.Clear();

    // Store an action that prints each number (RIGHT!)
    numbers.ForEach(number =>
        actions.Add(() => Console.WriteLine(number)));

    // Run the actions
    foreach (Action action in actions)
        action();

列表中。每个方法都没有这个问题。迭代的当前项按值作为参数传递给外部lambda，然后内部lambda在自己的闭包中正确地捕获该参数。问题解决了。

(遗憾的是，我认为ForEach是List的成员，而不是扩展方法，尽管很容易自己定义它，因此您可以在任何可枚举类型上使用此功能。)

其次，ForEach方法有一定的局限性。如果你通过使用yield return来实现IEnumerable，你不能在lambda中做yield return。因此，通过循环遍历集合中的项以获得返回值是不可能的。您必须使用foreach关键字，并通过手动在循环中复制当前循环值来解决闭包问题。

更多的在这里

需要注意的一件事是如何退出Generic . foreach方法——请参阅本讨论。虽然链接上似乎写着这条路最快。不知道为什么-你会认为一旦编译它们就会等价…

在幕后，匿名委托被转换为一个实际的方法，因此如果编译器没有选择内联函数，那么第二个选择可能会有一些开销。此外，匿名委托示例主体引用的任何局部变量在本质上都会发生变化，因为编译器会使用一些技巧来隐藏它被编译为新方法的事实。这里有更多关于c#如何做到这一点的信息:

http://blogs.msdn.com/oldnewthing/archive/2006/08/04/688527.aspx

常言道，细节决定成败……

两种集合枚举方法的最大区别是foreach携带状态，而foreach (x =>{})不携带状态。

但是让我们深入挖掘一下，因为有一些事情您应该知道，这些事情可能会影响您的决定，并且在为这两种情况编写代码时，您应该注意一些注意事项。

让我们在我们的小实验中使用List<T>来观察行为。在这个实验中，我使用的是。net 4.7.2:

var names = new List<string>
{
    "Henry",
    "Shirley",
    "Ann",
    "Peter",
    "Nancy"
};

让我们先用foreach遍历这个:

foreach (var name in names)
{
    Console.WriteLine(name);
}

我们可以将其展开为:

using (var enumerator = names.GetEnumerator())
{

}

有了枚举器在手，查看被罩下的内容，我们得到:

public List<T>.Enumerator GetEnumerator()
{
  return new List<T>.Enumerator(this);
}
    internal Enumerator(List<T> list)
{
  this.list = list;
  this.index = 0;
  this.version = list._version;
  this.current = default (T);
}

public bool MoveNext()
{
  List<T> list = this.list;
  if (this.version != list._version || (uint) this.index >= (uint) list._size)
    return this.MoveNextRare();
  this.current = list._items[this.index];
  ++this.index;
  return true;
}

object IEnumerator.Current
{
  {
    if (this.index == 0 || this.index == this.list._size + 1)
      ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
    return (object) this.Current;
  }
}

有两点是显而易见的:

返回一个有状态对象，并对底层集合了如指掌。 集合的副本是浅副本。

当然，这绝不是线程安全的。正如上面所指出的，在迭代时更改集合是不好的。

但是在迭代过程中，由于我们之外的人在迭代过程中破坏集合而导致集合失效的问题怎么办?最佳实践建议在操作和迭代期间对集合进行版本控制，并检查版本以检测底层集合何时发生变化。

这就是事情变得真正模糊的地方。根据微软文档:

如果对集合进行了更改，例如添加、修改或 删除元素时，枚举器的行为是未定义的。

那是什么意思呢?举例来说，仅仅因为List<T>实现了异常处理，并不意味着所有实现IList<T>的集合都会做同样的事情。这似乎明显违反了利斯科夫替换原则:

父类的对象可以被父类的对象替换 子类，而不会破坏应用程序。

另一个问题是枚举器必须实现IDisposable——这意味着潜在内存泄漏的另一个来源，不仅是调用者弄错了，而且作者没有正确实现Dispose模式。

最后，我们有一个终生的问题…如果迭代器是有效的，但底层集合已经没有了，会发生什么?我们现在看到的是……当你分离一个集合的生命周期和它的迭代器时，你是在自找麻烦。

现在让我们检查ForEach(x => {}):

names.ForEach(name =>
{

});

这扩展为:

public void ForEach(Action<T> action)
{
  if (action == null)
    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
  int version = this._version;
  for (int index = 0; index < this._size && (version == this._version || !BinaryCompatibility.TargetsAtLeast_Desktop_V4_5); ++index)
    action(this._items[index]);
  if (version == this._version || !BinaryCompatibility.TargetsAtLeast_Desktop_V4_5)
    return;
  ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
}

值得注意的是:

For (int index = 0;索引< this。_size &&…； + +指数) 操作(this._items(指数));

这段代码没有分配任何枚举数(没有要Dispose的枚举数)，并且在迭代时没有暂停。

注意，这也执行底层集合的浅拷贝，但是集合现在是一个及时快照。如果作者没有正确地实现集合更改或“过时”的检查，快照仍然有效。

这并不能以任何方式保护你免受终身问题的困扰……如果底层的集合消失了，你现在就有了一个浅拷贝，它指向…但至少你不需要处理孤立迭代器上的Dispose问题…

是的，我说的是迭代器……有时拥有国家是有利的。假设您想要维护类似于数据库游标的东西……也许多重foreach风格的Iterator<T>'s是可行的。我个人不喜欢这种设计风格，因为有太多的寿命问题，你依赖于你所依赖的集合的作者的好意(除非你真的从头开始写所有东西)。

总有第三个选择……

for (var i = 0; i < names.Count; i++)
{
    Console.WriteLine(names[i]);
}

它并不性感，但它有牙齿(向汤姆·克鲁斯和电影《公司》道歉)

这是你的选择，但现在你知道了，这是一个明智的选择。