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 ,

@ Джон Скит и все, кто предпочитает ключевое слово 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);
        }
    }
}

Извиняюсь за чрезмерно надуманный пример. Я использую только 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, 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.

РЕДАКТИРОВАТЬ: Если это не было ясно, любое использование этого метода должно заканчиваться 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 перечислять.

Держите ваши побочные эффекты от моего IEnumerable

Я хотел бы сделать эквивалент следующего в LINQ, но я не могу понять, как:

Как отмечают другие здесь и за рубежом, LINQ и IEnumerableметоды, как ожидается, будут свободны от побочных эффектов.

Вы действительно хотите «сделать что-то» с каждым элементом в IEnumerable? Тогда foreachэто лучший выбор. Люди не удивляются, когда здесь происходят побочные эффекты.

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

Бьюсь об заклад, вы не хотите побочный эффект

Однако по моему опыту побочные эффекты обычно не требуются. Чаще всего существует простой запрос LINQ, ожидающий своего открытия, сопровождаемый ответом StackOverflow.com от Jon Skeet, Eric Lippert или Marc Gravell, объясняющих, как делать то, что вы хотите!

Некоторые примеры

Если вы на самом деле просто агрегируете (накапливаете) какое-то значение, вам следует рассмотреть 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 для получения дополнительных ссылок). 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пространстве имен все еще есть опция , если у вас уже есть ссылка на Reactive Extension (и если вы этого не делаете , Вы должны иметь):

using System.Reactive.Linq;

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

Хотя имена методов немного отличаются, конечный результат - именно то, что вы ищете.

ForEach также может быть Chained , просто положить обратно в pileline после действия. оставаться в курсе

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