我想在LINQ中执行以下等效操作，但我无法确定如何执行：
IEnumerable<Item> items = GetItems();
items.ForEach(i => i.DoStuff());
真正的语法是什么？
当前回答
让你的副作用远离我的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))
可能性的列表（双关语并非完全有意）还在继续。
其他回答
ForEach的目的是造成副作用。IEnumerable用于集合的惰性枚举。
当你考虑到这一点时，这个概念上的差异是非常明显的。
SomeEnumerable.ForEach（item=>DataStore.Synchronize（item））；
在您对其执行“计数”或“ToList（）”或其他操作之前，这不会执行。这显然不是所表达的。
您应该使用IEnumerable扩展来设置迭代链，根据其各自的源和条件定义内容。表达树是强大而高效的，但你应该学会欣赏它们的本质。而且不仅仅是为了围绕它们进行编程，以节省几个字符而忽略惰性求值。
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<Item> items = GetItems();
foreach (var item in items) item.DoStuff();
简短而简单（st）。
我分别不同意链接扩展方法应该是无副作用的概念（不仅因为它们不是，任何委托都可以执行副作用）。
考虑以下事项：
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编译）时验证了相同的行为。
推荐文章
- 如何检查IEnumerable是否为空或空?
- 使用linq转换列表到字典，不用担心重复
- 返回匿名类型的结果?
- SQL to LINQ工具
- LINQ读取XML
- 在链式LINQ扩展方法调用中等价于'let'关键字的代码
- 从另一个列表id中排序一个列表
- 从IEnumerable<KeyValuePair<>>重新创建字典
- Lookup()和Dictionary(Of list()的区别
- 关联数组对象上的JavaScript foreach循环
- for-each循环和迭代器，哪个更有效?
- 如何改变列表<T>数据IQueryable<T>数据
- 如果查询为空，则最大返回值
- ToList()——它是否创建一个新列表?
- 如何将linq结果转换为哈希集或哈希集
