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

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

Но это вовсе не значит это - плохая вещь сделать - просто думающий о философских причинах позади решения.

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

Примите во внимание следующее:

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

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

Я взял метод Фредрика и изменил возвращаемый тип.

Таким образом, метод поддерживает отложенное выполнение, как и другие методы 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 перечислять.

Еще один 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;
}

ForEach предназначен для создания побочных эффектов. IEnumerable предназначен для ленивого перечисления набора.

Это концептуальное различие вполне заметно, если его рассмотреть.

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

Это не будет выполнено, пока вы не сделаете "count" или "ToList()" или что-то в этом роде. Это явно не то, что выражено.

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