IEnumerable没有ForEach扩展；仅适用于列表＜T＞。所以你可以

items.ToList().ForEach(i => i.DoStuff());

或者，编写自己的ForEach扩展方法：

public static void ForEach<T>(this IEnumerable<T> enumeration, Action<T> action)
{
    foreach(T item in enumeration)
    {
        action(item);
    }
}

在Jon Skeet的启发下，我扩展了他的解决方案：

扩展方法：

public static void Execute<TSource, TKey>(this IEnumerable<TSource> source, Action<TKey> applyBehavior, Func<TSource, TKey> keySelector)
{
    foreach (var item in source)
    {
        var target = keySelector(item);
        applyBehavior(target);
    }
}

客户：

var jobs = new List<Job>() 
    { 
        new Job { Id = "XAML Developer" }, 
        new Job { Id = "Assassin" }, 
        new Job { Id = "Narco Trafficker" }
    };

jobs.Execute(ApplyFilter, j => j.Id);

...

    public void ApplyFilter(string filterId)
    {
        Debug.WriteLine(filterId);
    }

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

考虑以下事项：

   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);
      }
   }

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

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

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

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

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

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

MoreLinq有IEnumerable<T>.ForEach和许多其他有用的扩展。仅为ForEach使用依赖关系可能不值得，但其中有很多有用的东西。

https://www.nuget.org/packages/morelinq/

https://github.com/morelinq/MoreLINQ

Fredrik提供了解决方案，但可能值得考虑一下为什么这不在框架中。我认为，LINQ查询运算符应该是无副作用的，符合合理的功能性世界观。很明显，ForEach恰恰相反——一个纯粹基于副作用的构造。

这并不是说这是一件坏事——只是想想这个决定背后的哲学原因。