微软发布了一个LINQ交互扩展的实验版本（也在NuGet上，更多链接请参见RxTeams的简介）。9频道的视频很好地解释了这一点。

它的文档仅以XML格式提供。我在Sandcastle中运行了这个文档，以使其具有更可读的格式。解压缩文档存档并查找index.html。

在许多其他好处中，它提供了预期的ForEach实现。它允许您编写如下代码：

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8 };

numbers.ForEach(x => Console.WriteLine(x*x));

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

考虑以下事项：

   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扩展的一个非常重要的问题：性能！更具体地说，内存使用和GC。

考虑以下示例。针对.NET Framework 4.7.2或.NET Core 3.1.401，配置为Release，平台为Any CPU。

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

class Program
{
    private static void NoOp(int value) {}

    static void Main(string[] args)
    {
        var list = Enumerable.Range(0, 10).ToList();
        for (int i = 0; i < 1000000; i++)
        {
            // WithLinq(list);
            // WithoutLinqNoGood(list);
            WithoutLinq(list);
        }
    }

    private static void WithoutLinq(List<int> list)
    {
        foreach (var item in list)
        {
            NoOp(item);
        }
    }

    private static void WithLinq(IEnumerable<int> list) => list.ForEach(NoOp);

    private static void WithoutLinqNoGood(IEnumerable<int> enumerable)
    {
        foreach (var item in enumerable)
        {
            NoOp(item);
        }
    }
}

乍一看，这三种变体都应该表现得同样出色。然而，当ForEach扩展方法被多次调用时，最终会产生垃圾，这意味着代价高昂的GC。事实上，在热路径上使用此ForEach扩展方法已被证明会完全破坏循环密集型应用程序的性能。

类似地，弱类型的foreach循环也会产生垃圾，但它仍然比foreach扩展更快，占用的内存更少（它也会受到委托分配的影响）。

强类型foreach：内存使用

弱类型foreach：内存使用

ForEach扩展：内存使用

分析

对于强类型foreach，编译器可以使用类的任何优化枚举器（例如基于值的），而泛型foreach扩展必须返回到将在每次运行时分配的泛型枚举器。此外，实际代表还将意味着额外分配。

使用WithoutLinqNoGood方法也会得到类似的坏结果。在那里，参数的类型是IEnumerable＜int＞，而不是List＜int＞。这意味着相同类型的枚举器分配。

以下是IL中的相关差异。基于值的枚举器当然更可取！

IL_0001:  callvirt   instance class
          [mscorlib]System.Collections.Generic.IEnumerator`1<!0> 
          class [mscorlib]System.Collections.Generic.IEnumerable`1<!!T>::GetEnumerator()

vs

IL_0001:  callvirt   instance valuetype
          [mscorlib]System.Collections.Generic.List`1/Enumerator<!0>
          class [mscorlib]System.Collections.Generic.List`1<int32>::GetEnumerator()

结论

OP询问如何在IEnumerable＜T＞上调用ForEach（）。最初的答案清楚地表明了如何做到这一点。当然你能做到，但再说一遍；我的回答清楚地表明你不应该。

在针对.NET Core 3.1.401（使用Visual Studio 16.7.2编译）时验证了相同的行为。

现在我们可以选择。。。

        ParallelOptions parallelOptions = new ParallelOptions();
        parallelOptions.MaxDegreeOfParallelism = 4;
#if DEBUG
        parallelOptions.MaxDegreeOfParallelism = 1;
#endif
        Parallel.ForEach(bookIdList, parallelOptions, bookID => UpdateStockCount(bookID));

当然，这打开了一个全新的线虫罐头。

ps（对不起，字体是系统决定的）

您可以使用FirstOrDefault（）扩展，该扩展可用于IEnumerable＜T＞。通过从谓词返回false，它将为每个元素运行，但不会在意它实际上没有找到匹配项。这将避免ToList（）开销。

IEnumerable<Item> items = GetItems();
items.FirstOrDefault(i => { i.DoStuff(); return false; });

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

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

https://github.com/morelinq/MoreLINQ