int result;
result = seq.NullCount();
result = seq.NullCount(); // usually good

result = seq.ForEach(action);
result = seq.ForEach(action); // usually bad

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

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

        public static void ForEach(this IEnumerable collection, Action<object> func)
        {
            foreach (object value in collection)
                func(value);
        }

using System;
using System.Collections.Generic;

namespace WhereForeach
{
    static class Program
    {
        static IEnumerable<int> TestEnum()
        {
            yield return 1;
            Console.WriteLine(1);
            yield return 2;
            Console.WriteLine(2);
            yield return 3;
            Console.WriteLine(3);
        }

        public static void ForEach<T>(this IEnumerable<T> source, Action<T> action, Func<T, bool> filter)
        {
            foreach (var item in source)
                if (filter(item))
                    action(item);
        }

        static void Main()
        {
            TestEnum().ForEach(i => Console.WriteLine("Action " + i), i => i == 2);
        }
    }
}

_FR>Во ё-моё, а мне казалось что эта команда заставляет отладчик перепрыгнуть к курсору

...для запуска отладчика и выполнения кода до позиции курсора

Tom>Хочется что бы был один запрос

servicesInDatabase.Concat(servicesLocal).Except(servicesInDatabase.Intersect(servicesLocal)).ToList().ForEach(Console.WriteLine);

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

L>foreach (var x in list.Where(Condition))DoSmth(x);
L>

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

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

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

Tom>var servicesInDatabase = new List<string>() {"s1", "s2", "s3", "s10"};
Tom>var servicesLocal = new List<string>() { "s1", "s2", "s4", "s5"};

Tom>servicesInDatabase.Except(servicesLocal).ToList().ForEach(Console.WriteLine /*Actually we'to DELETE services here*/);
Tom>servicesLocal.Except(servicesInDatabase).ToList().ForEach(Console.WriteLine /*Actually we'to CREATE services here*/);

public static void Main(string args[])
{
  SinclairLib.ForEach(args, Console.WriteLine);
}

ВВ>static IEnumerable<Int32> ForEach(this IEnumerable<Int32> self, Func<Int32,Boolean> cond, Action<Int32> act)
ВВ>{
ВВ>    foreach (var i in self)
ВВ>        if (condition(i))
ВВ>            action(i);
ВВ>}
ВВ>

ВВ>static IEnumerable<Int32> ForEach(this IEnumerable<Int32> self, Func<Int32,Boolean> cond, Action<Int32> act)
ВВ>{
ВВ>  foreach (var i in self)
ВВ>     if (condition(i))
ВВ>     {
ВВ>       action(i);
ВВ>       yield return i;
ВВ>     }
ВВ>}
ВВ>

ВВ>А это ты уже сам проверь

ВВ>var it = arr.ForEach(i => i < 2, Console.WriteLine).ForEach(i => i < 3, Console.WriteLine);
ВВ>

ВВ>T Aggregate<T>(this IEnumerable<T> self, Func<T,T,T> func);
ВВ>

ВВ>Очень интересно будет послушать

Func<T> Aggregate<T> (this IEnumerable<T> self, Func<T, T, T> aggregate)

ВВ>Согласен

ВВ>Суть-то конечно не в том, чтобы ForEach превращать в ленивую чистую и светлую функцию. Ленивая — ну может иногда это имеет смысл. Чистая — ну может практически никогда Ну и что с того? Вот вернемся к Aggregate. У меня половина использований этой ф-ции может иметь побочные эффекты. А знаешь почему? Потому что 1) агрегаты сложные, может быть несколько аккумуляторов, сложное состояние

ВВ>int y = 0;            
ВВ>Func<Int32,Int32> f = x => y += x;
ВВ>

ВВ>А нафига? Мнение Липерта закон? Странно вот получается, на Фаулера с Эвансом вам насрать, а Липерт — уже икона.

ВВ>cargo.ForEach(c => c.WeightLimited && c.Weight > LIMIT, c => ThrowException(c.UniqueId, c.Weight));
ВВ>

            var wrongCargo = cargo.FirstOrDefault(c => c.WeightLimited && c.Weight > LIMIT);

            if (wrongCargo != null)
                ThrowException(wrongCargo.UniqueId, wrongCargo.Weight));

    int[] a = new[] {1, 2, 4, 5, 7, 8, 9};
    int t = 0;
    var w = 6;
    var rucksack = a.Where(x => (t += x) <= w);

ВВ>>var arr = new int[]{ 1, 1, 1, 2, 2, 2, 3, 3, 3};            
ВВ>>var it = arr.ForEach(i => i < 2, Console.WriteLine).ForEach(i => i < 3, Console.WriteLine);
ВВ>>

using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var arr = new int[]{ 1, 1, 1, 2, 2, 2, 3, 3, 3};            
        var it = arr.ForEach(i => i < 2, Console.WriteLine).ForEach(i => i < 3, Console.WriteLine);
        
        foreach (var v in it)
        {}
    }
}

static class Iterator
{
    public static IEnumerable<T> ForEach<T>(this IEnumerable<T> self, Func<T,Boolean> condition, Action<T> action)
    {
        foreach (var v in self)
            if (condition(v))
            {
                action(v);
                yield return v;
            }
    }
}

ВВ>>А куда стандартная делась?

ВВ>>Да, пусть вероятность наличия побочных эффектов в данном действии 99 к 1 — но мы же не вероятность обсуждаем, а дизайн?

var servicesInDatabase = new List<string>() {"s1", "s2", "s3", "s10"};
var servicesLocal = new List<string>() { "s1", "s2", "s4", "s5"};

servicesInDatabase.Except(servicesLocal).ToList().ForEach(Console.WriteLine /*Actually we'to DELETE services here*/);
servicesLocal.Except(servicesInDatabase).ToList().ForEach(Console.WriteLine /*Actually we'to CREATE services here*/);

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

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

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

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

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

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

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) {...}

ВВ>А в твоем случае красивее будет?

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

[CompilerGenerated]
private sealed class <ExceptIterator>d__92<TSource> : IEnumerable<TSource>, IEnumerable, IEnumerator<TSource>, IEnumerator, IDisposable
{
    // Fields
    private int <>1__state;
    private TSource <>2__current;
    public IEqualityComparer<TSource> <>3__comparer;
    public IEnumerable<TSource> <>3__first;
    public IEnumerable<TSource> <>3__second;
    public IEnumerator<TSource> <>7__wrap95;
    private int <>l__initialThreadId;
    public TSource <element>5__94;
    public Set<TSource> <set>5__93;
    public IEqualityComparer<TSource> comparer;
...
...
}

_FR>> Расскажи пожалуйста о преимуществах Where в данном конкретном примере над if.

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

…такая возможность ничего не добавляет к выразительности языка…

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

…Когда мы предоставляем два почти одинаковых способа сделать в точности одну вещь, мы вносим сумятицу в индустрию, мы затрудняем людям чтение кода друг друга, и так далее

IB>Видимо стоило, все-таки по русски. Ну ладно, я разжую. Аргументов там два, и оба отличаются от того, который ты нашел:

Some1();

for(var x in yy) {
  // … сотня-другая итераций
}//fir

Some2();

А>не пиши мне. читай липберта.

Если вы не согласны с этими философскими возражениями и находите в этом приёме практическую ценность, определенно не сдерживайте себя и напишите эту тривиальную строчку сами.

А>правда? я не знал, спасибо что подсказал. юзай стандартный цикл for. он куда более стандартен, понятен, доступен

ВВ>К сожалению, Линк не предоставляет нормальных средств для дебага — а так бы увидели, что это не так

using System;
using System.Collections.Generic;
using System.Linq;

namespace WhereForeach
{
    static class Program
    {
        static IEnumerable<int> TestEnum()
        {
            yield return 1;
            Console.WriteLine(1);
            yield return 2;
            Console.WriteLine(2);
            yield return 3;
            Console.WriteLine(3);
        }

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

        static void Main()
        {
            TestEnum().Where(i => i == 2).ForEach(i => Console.WriteLine("Action " + i));
        }
    }
}

1
Action 2
2
3

public static void Main(string args[])
{
  args.ForEach(Console.WriteLine);
}

public static void Main(string args[])
{
  foreach(var a in args)
        Console.WriteLine(a);
}

Мне как-то не нравится идея сделать единственный оператор для последовательностей, который полезен только для спецэффектов.

_FR>>Вот ещё один толкователь Мужики, вы понятным языком можете рассказать, что и где вы там видите или сами понимаете?

  static class Sequence
  {
    public static void ForEach<TSource>(this IEnumerable<TSource> source, Action<TSource> action) {
      foreach(var item in source) {
        action(item);
      }//for
    }
  }

var x = list.ForEach(action, condition);