我采用了Fredrik的方法并修改了返回类型。

这样，该方法与其他LINQ方法一样支持延迟执行。

EDIT：如果这一点不清楚，则此方法的任何用法都必须以ToList（）或任何其他方式结束，以强制该方法处理完整的可枚举对象。否则，将不会执行该操作！

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

下面是帮助您了解它的测试：

[Test]
public void TestDefferedExecutionOfIEnumerableForEach()
{
    IEnumerable<char> enumerable = new[] {'a', 'b', 'c'};

    var sb = new StringBuilder();

    enumerable
        .ForEach(c => sb.Append("1"))
        .ForEach(c => sb.Append("2"))
        .ToList();

    Assert.That(sb.ToString(), Is.EqualTo("121212"));
}

如果最后删除ToList（），则会看到测试失败，因为StringBuilder包含一个空字符串。这是因为没有方法强制ForEach枚举。

2012年7月17日更新：显然，从C#5.0开始，下面描述的foreach的行为已经改变，“在嵌套lambda表达式中使用foreach迭代变量不再产生意外结果。”这个答案不适用于C#≥5.0。

@约翰·斯基特和所有喜欢foreach关键字的人。

5.0之前的C#中的“foreach”的问题是，它与其他语言中等效的“for understanding”的工作方式不一致，也与我期望它的工作方式（此处陈述的个人观点仅是因为其他人提到了他们对可读性的看法）不一致。查看有关“修改关闭的访问”的所有问题以及“关闭被认为有害的循环变量”。这只是“有害的”，因为“foreach”是在C#中实现的。

使用@Fredrik Kalseth的答案中功能等效的扩展方法，以下面的示例为例。

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

为这个过于做作的例子道歉。我只使用Observable，因为这样做并不完全牵强。显然，有更好的方法来创建这种可观察性，我只是试图证明一点。通常，订阅可观察到的代码是异步执行的，并且可能在另一个线程中执行。如果使用“foreach”，这可能会产生非常奇怪且可能不确定的结果。

使用“ForEach”扩展方法的以下测试通过：

[Test]
public void ForEachExtensionWin()
{
    //Yes, I know there is an Observable.Range.
    var values = Enumerable.Range(0, 10);

    var observable = Observable.Create<Func<int>>(source =>
                            {
                                values.ForEach(value => 
                                    source.OnNext(() => value));

                                source.OnCompleted();
                                return () => { };
                            });

    //Simulate subscribing and evaluating Funcs
    var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList();

    //Win
    Assert.That(evaluatedObservable, 
        Is.EquivalentTo(values.ToList()));
}

以下操作失败并出现错误：

应为：相当于<0，1，2，3，4，5，6，7，8，9>但是：<9，9，9

[Test]
public void ForEachKeywordFail()
{
    //Yes, I know there is an Observable.Range.
    var values = Enumerable.Range(0, 10);

    var observable = Observable.Create<Func<int>>(source =>
                            {
                                foreach (var value in values)
                                {
                                    //If you have resharper, notice the warning
                                    source.OnNext(() => value);
                                }
                                source.OnCompleted();
                                return () => { };
                            });

    //Simulate subscribing and evaluating Funcs
    var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList();

    //Fail
    Assert.That(evaluatedObservable, 
        Is.EquivalentTo(values.ToList()));
}

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

ForEach也可以链接，只需在动作后放回桩线即可。保持流利

Employees.ForEach(e=>e.Act_A)
         .ForEach(e=>e.Act_B)
         .ForEach(e=>e.Act_C);

Orders  //just for demo
    .ForEach(o=> o.EmailBuyer() )
    .ForEach(o=> o.ProcessBilling() )
    .ForEach(o=> o.ProcessShipping());


//conditional
Employees
    .ForEach(e=> {  if(e.Salary<1000) e.Raise(0.10);})
    .ForEach(e=> {  if(e.Age   >70  ) e.Retire();});

实现的一个版本。

public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enu, Action<T> action)
{
    foreach (T item in enu) action(item);
    return enu; // make action Chainable/Fluent
}

编辑：Lazy版本使用的是收益率返回，如下所示。

public static IEnumerable<T> ForEachLazy<T>(this IEnumerable<T> enu, Action<T> action)
{
    foreach (var item in enu)
    {
        action(item);
        yield return item;
    }
}

Lazy版本需要具体化，例如ToList（），否则什么都不会发生。请参阅以下ToolmakerSteve的精彩评论。

IQueryable<Product> query = Products.Where(...);
query.ForEachLazy(t => t.Price = t.Price + 1.00)
    .ToList(); //without this line, below SubmitChanges() does nothing.
SubmitChanges();

我将ForEach（）和ForEachLazy（）都保存在库中。

微软发布了一个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));

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

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