让你的副作用远离我的IEnumerable

我想在LINQ中执行以下等效操作，但我无法确定如何执行：

正如其他人在国内外指出的，LINQ和IEnumerable方法预计不会产生副作用。

你真的想对IEnumerable中的每个项目“做点什么”吗？那么foreach是最好的选择。当这里出现副作用时，人们并不感到惊讶。

foreach (var i in items) i.DoStuff();

我打赌你不想有副作用

然而，根据我的经验，通常不需要副作用。通常情况下，有一个简单的LINQ查询等待被发现，并伴随着Jon Skeet、Eric Lippert或Marc Gravell的StackOverflow.com回答，解释如何做您想要的事情！

一些示例

如果您实际上只是在聚合（累积）一些值，那么应该考虑聚合扩展方法。

items.Aggregate(initial, (acc, x) => ComputeAccumulatedValue(acc, x));

也许您想从现有值创建一个新的IEnumerable。

items.Select(x => Transform(x));

或者你想创建一个查找表：

items.ToLookup(x, x => GetTheKey(x))

可能性的列表（双关语并非完全有意）还在继续。

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

我采用了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枚举。

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

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

在IEnumerable上执行并行foreach循环。

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

考虑以下事项：

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

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

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