这种“功能方法”抽象泄露了大量时间。在语言层面上没有任何东西可以防止副作用。只要你能让它为容器中的每个元素调用lambda/委托，你就会得到“ForEach”行为。

例如，这里有一种将srcDictionary合并到destDictionary的方法（如果键已经存在-重写）

这是一个黑客，不应该在任何生产代码中使用。

var b = srcDictionary.Select(
                             x=>
                                {
                                  destDictionary[x.Key] = x.Value;
                                  return true;
                                }
                             ).Count();

为了保持流利，可以使用以下技巧：

GetItems()
    .Select(i => new Action(i.DoStuf)))
    .Aggregate((a, b) => a + b)
    .Invoke();

我分别不同意链接扩展方法应该是无副作用的概念（不仅因为它们不是，任何委托都可以执行副作用）。

考虑以下事项：

   public class Element {}

   public Enum ProcessType
   {
      This = 0, That = 1, SomethingElse = 2
   }

   public class Class1
   {
      private Dictionary<ProcessType, Action<Element>> actions = 
         new Dictionary<ProcessType,Action<Element>>();

      public Class1()
      {
         actions.Add( ProcessType.This, DoThis );
         actions.Add( ProcessType.That, DoThat );
         actions.Add( ProcessType.SomethingElse, DoSomethingElse );
      }

      // Element actions:

      // This example defines 3 distict actions
      // that can be applied to individual elements,
      // But for the sake of the argument, make
      // no assumption about how many distict
      // actions there may, and that there could
      // possibly be many more.

      public void DoThis( Element element )
      {
         // Do something to element
      }

      public void DoThat( Element element )
      {
         // Do something to element
      }

      public void DoSomethingElse( Element element )
      {
         // Do something to element
      }

      public void Apply( ProcessType processType, IEnumerable<Element> elements )
      {
         Action<Element> action = null;
         if( ! actions.TryGetValue( processType, out action ) )
            throw new ArgumentException("processType");
         foreach( element in elements ) 
            action(element);
      }
   }

该示例显示的实际上只是一种后期绑定，它允许调用对元素序列有副作用的许多可能的操作之一，而不必编写大开关构造来解码定义该操作的值并将其转换为相应的方法。

根据PLINQ（从.Net 4.0开始提供），您可以执行

IEnumerable<T>.AsParallel().ForAll() 

在IEnumerable上执行并行foreach循环。

对于VB.NET，应使用：

listVariable.ForEach(Sub(i) i.Property = "Value")

ForEach的目的是造成副作用。IEnumerable用于集合的惰性枚举。

当你考虑到这一点时，这个概念上的差异是非常明显的。

SomeEnumerable.ForEach（item=>DataStore.Synchronize（item））；

在您对其执行“计数”或“ToList（）”或其他操作之前，这不会执行。这显然不是所表达的。

您应该使用IEnumerable扩展来设置迭代链，根据其各自的源和条件定义内容。表达树是强大而高效的，但你应该学会欣赏它们的本质。而且不仅仅是为了围绕它们进行编程，以节省几个字符而忽略惰性求值。