LINQ еквівалент foreach для IEnumerable <T>

Я хотів би зробити еквівалент наступного в LINQ, але не можу зрозуміти, як:

IEnumerable<Item> items = GetItems();
items.ForEach(i => i.DoStuff());

Що таке справжній синтаксис?

Немає розширення ForEach для IEnumerable; тільки для List<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);
    }
}

Фредрік надав виправлення, але, можливо, варто подумати, чому це не в рамках, для початку. Я вважаю, що ідея полягає в тому, що оператори запитів LINQ повинні бути без побічних ефектів, які відповідають розумно функціональним способом погляду на світ. Зрозуміло, що ForEach - це якраз навпаки - суто побічна конструкція.

Це не означає, що це погано - просто думати про філософські причини, що стоять за рішенням.

Оновлення 17.07.2012: Мабуть, станом на C # 5.0, поведінка foreachописаної нижче змінилася, і " використання foreachзмінної ітерації в вкладеному лямбда-виразі більше не дає несподіваних результатів ". Ця відповідь не стосується C # ≥ 5.0 .

@John Skeet і всі, хто віддає перевагу ключовому слову foreach.

Проблема "foreach" в C # до 5,0 , полягає в тому, що вона не відповідає тому, як працює еквівалент "для розуміння" іншими мовами, і як я б очікував, що це буде працювати (особиста думка, викладена тут лише тому, що інші згадували про своє думка щодо читабельності). Перегляньте всі питання, що стосуються " Доступ до модифікованого закриття ", а також " Закриття змінної циклу, що вважається шкідливим ". Це лише "шкідливо" через те, як "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);
        }
    }
}

Вибачення за надмірно надуманий приклад. Я використовую лише спостережуване, тому що робити щось подібне не зовсім далеко. Очевидно, що є кращі способи створити це спостережуване, я лише намагаюся продемонструвати точку. Зазвичай код, підписаний на спостережуване, виконується асинхронно і потенційно в іншій потоці. Якщо використовувати "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, 9, 9, 9, 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()));
}

Ви можете використовувати FirstOrDefault()розширення, яке доступне для IEnumerable<T>. Повернувшись falseіз присудка, він буде запущений для кожного елемента, але не буде байдужим, що він насправді не знайде відповідності. Це дозволить уникнути ToList()накладних витрат.

IEnumerable<Item> items = GetItems();
items.FirstOrDefault(i => { i.DoStuff(); return false; });

Я взяв метод Фредріка і змінив тип повернення.

Таким чином, метод підтримує відкладене виконання як і інші методи 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 перерахувати.

Тримайте ваші побічні ефекти від моїх безлічі

Я хотів би зробити еквівалент наступного в LINQ, але не можу зрозуміти, як:

Як вказували інші тут і за кордоном LINQ іIEnumerable , очікується, що методи не мають побічних ефектів.

Ви дійсно хочете "зробити щось" для кожного пункту в IEnumerable? Тоді foreachнайкращий вибір. Люди не здивовані, коли тут виникають побічні ефекти.

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

Б'юсь об заклад, що ви не хочете побічного ефекту

Однак, на мій досвід, побічні ефекти зазвичай не потрібні. Найчастіше існує простий запит LINQ, який очікує на виявлення, а також відповідь StackOverflow.com або Джон Скіт, Ерік Ліпперт, або Марк Гравелл, що пояснює, як робити те, що ви хочете!

Деякі приклади

Якщо ви насправді просто агрегуєте (накопичуєте) якесь значення, то слід розглянути Aggregateметод розширення.

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

Можливо, ви хочете створити нове IEnumerableз існуючих значень.

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

Або, можливо, ви хочете створити таблицю перегляду:

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

Список можливостей (каламбур не зовсім призначений) продовжується та продовжується.

Якщо ви хочете виконувати роль перерахунку, ви повинні отримати кожен елемент.

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

Існує експериментальна версія Microsoft Interactive Extensions до LINQ (також на NuGet , див . Профіль RxTeams для отримання додаткових посилань). Channel 9 відео пояснює це добре.

Документи надаються лише у форматі XML. Я запустив цю документацію в Sandcastle, щоб вона могла бути в більш читаному форматі. Розпакуйте архів документів і знайдіть index.html .

Серед багатьох інших вигод, він забезпечує очікуване впровадження ForEach. Це дозволяє писати такий код:

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8 };

numbers.ForEach(x => Console.WriteLine(x*x));

Відповідно до PLINQ (доступний з .Net 4.0), ви можете зробити це

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

зробити паралельний цикл foreach на IEnumerable.

Мета ForEach - викликати побічні ефекти. IEnumerable - це для ледачого перерахування набору.

Ця концептуальна різниця досить помітна, коли ви її враховуєте.

SomeEnumerable.ForEach(item=>DataStore.Synchronize(item));

Це звичайне виконання, поки ви не зробите "count" або "ToList ()" чи щось на ньому. Це явно не те, що виражається.

Ви повинні використовувати розширення IEnumerable для налаштування ланцюгів ітерації, визначення вмісту за відповідними джерелами та умовами. Дерева виразів потужні та ефективні, але вам слід навчитися цінувати їх природу. І не тільки для програмування навколо них, щоб зберегти кілька символів, що переважають ледачу оцінку.

Багато людей згадували про це, але мені довелося це записати. Хіба це не найяскравіше / найчитабельніше?

IEnumerable<Item> items = GetItems();
foreach (var item in items) item.DoStuff();

Короткий і простий (ст).

Тепер у нас є можливість ...

        ParallelOptions parallelOptions = new ParallelOptions();
        parallelOptions.MaxDegreeOfParallelism = 4;
#if DEBUG
        parallelOptions.MaxDegreeOfParallelism = 1;
#endif
        Parallel.ForEach(bookIdList, parallelOptions, bookID => UpdateStockCount(bookID));

Звичайно, це відкриває цілком нову банку ниток.

ps (Вибачте за шрифти, це вирішила система)

Як уже зазначаються численні відповіді, ви можете легко додати такий метод розширення самостійно. Однак якщо ви цього не хочете робити, хоча мені в BCL нічого подібного не відомо, у Systemпросторі імен все ще є варіант , якщо ви вже маєте посилання на Реактивне розширення (і якщо ви цього не робите , ти повинен мати):

using System.Reactive.Linq;

items.ToObservable().Subscribe(i => i.DoStuff());

Хоча назви методів трохи відрізняються, кінцевий результат - саме те, що ви шукаєте.

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
}

Edit: Ледача версія використовує повернення прибутковості, як це .

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

Лідні версії НЕ потребують матеріалізації, наприклад, 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 () у своїй бібліотеці.

Цей "функціональний підхід" абстракція просочується великим часом. Ніщо на мовному рівні не запобігає побічним ефектам. Поки ви зможете викликати його лямбда / делегата для кожного елемента контейнера - ви отримаєте поведінку "ForEach".

Ось, наприклад, один із способів об’єднання srcDictionary в destDictionary (якщо ключ вже існує - перезаписується)

це злом, і його не слід використовувати в жодному виробничому коді.

var b = srcDictionary.Select(
                             x=>
                                {
                                  destDictionary[x.Key] = x.Value;
                                  return true;
                                }
                             ).Count();

Натхненний Джоном Скітом, я розширив його рішення наступним чином:

Спосіб розширення:

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

MoreLinq має IEnumerable<T>.ForEachі тону інших корисних розширень. Мабуть, не варто брати залежність лише зарадиForEach , але там є багато корисного.

https://www.nuget.org/packages/morelinq/

https://github.com/morelinq/MoreLINQ

Я з повагою не погоджуюся з думкою, що методи розширення посилань повинні бути без побічних ефектів (не тільки тому, що вони відсутні, будь-який делегат може виконувати побічні ефекти).

Розглянемо наступне:

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

Що показує приклад, насправді є лише різновидом пізньої прив'язки, який дозволяє викликати одну з багатьох можливих дій, що мають побічні ефекти на послідовність елементів, без необхідності писати велику конструкцію комутатора для декодування значення, що визначає дію та перекладати це у відповідний метод.

Щоб залишатися вільним, можна скористатися такою хитрістю:

GetItems()
    .Select(i => new Action(i.DoStuf)))
    .Aggregate((a, b) => a + b)
    .Invoke();

Для VB.NET слід використовувати:

listVariable.ForEach(Sub(i) i.Property = "Value")

Ще один ForEachприклад

public static IList<AddressEntry> MapToDomain(IList<AddressModel> addresses)
{
    var workingAddresses = new List<AddressEntry>();

    addresses.Select(a => a).ToList().ForEach(a => workingAddresses.Add(AddressModelMapper.MapToDomain(a)));

    return workingAddresses;
}