ВВ>list.ForEach(x => DoSmth(x), x => Condition(x));

list.Where(x => Condition(x)).ForEach(x => DoSmth(x));

list.Where(Condition).ForEach(DoSmth);

_FR>list.Where(Condition).ForEach(DoSmth);
_FR>

foreach (var x in list) if (Condition(x)) DoSmth(x);

ВВ>>foreach (var x in list)
ВВ>>  if (Condition(x))
ВВ>>    DoSmth(x);

1: foreach (var x in list)
2: {
3:   if (Condition(x))
4:   {
5:     DoSmth(x);
6:   }
7: }

list.Where(Condition).ForEach(DoSmth);

_FR>>list.Where(Condition).ForEach(DoSmth);

void ForEach<T>(this IEnumerable<T>, Action<T>);
void ForEach<T>(this IEnumerable<T>, Predicate<T>, Action<T>);

void ForEach<T>(this IEnumerable<T>, Action<T, int>);
void ForEach<T>(this IEnumerable<T>, Predicate<T>, Action<T, int>);

foreach (var x in list.Where(Condition))
{
  DoSmth(x);
}

Во-первых, это нарушило бы принципы функционального программирования, на которых основаны все остальные операторы на последовательностях.

Во-вторых, такая возможность ничего не добавляет к выразительности языка. Она всего лишь позволяет вам переписать вот этот идеально понятный код… (в другом виде [прим. _FRED_])

И вторую версию даже труднее понять и отладить, …

foos.ForEach((Foo foo)=>{ какой-то оператор с foo; });

foos.ForEach(DoSmth);

а еще она добавляет семантику замыкания, потенциально внося тонкие изменения в жизненные циклы объектов.

Z>foreach (var x in list.Where(Condition))
Z>{
Z>  DoSmth(x);
Z>}

ВВ>>Единственный аргумент там — то, что ForEach — это не функционально. Аргумент весьма своеобразный на мой взгляд. Я вот никогда не видел приложение на шарпе написанное целиком функционально. Да и в Линк при желании можно запихать побочных эффектов по самое не могу — и все будет прекрасно работать.

list.ForEach(x => { DoSmth(x); });

list.ForEach(delegate(Type x) => { DoSmth(x); });

static void ForEach<T>(this IEnumerable<T> inst, Action<T> act) {...}