Equivalente LINQ de foreach para IEnumerable <T>

Gostaria de fazer o equivalente ao seguinte no LINQ, mas não consigo descobrir como:

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

Qual é a sintaxe real?

Não há extensão ForEach para IEnumerable; apenas para List<T>. Então você poderia fazer

items.ToList().ForEach(i => i.DoStuff());

Como alternativa, escreva seu próprio método de extensão ForEach:

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

Fredrik forneceu a correção, mas pode valer a pena considerar por que isso não está na estrutura, para começar. Acredito que a idéia é que os operadores de consulta LINQ sejam livres de efeitos colaterais, adaptando-se a uma maneira razoavelmente funcional de olhar o mundo. Claramente, o ForEach é exatamente o oposto - uma construção puramente baseada em efeitos colaterais.

Isso não quer dizer que isso é uma coisa ruim a se fazer - basta pensar nas razões filosóficas por trás da decisão.

Atualização 7/17/2012: Aparentemente, a partir do C # 5.0, o comportamento foreachdescrito abaixo foi alterado e " o uso de uma foreachvariável de iteração em uma expressão lambda aninhada não produz mais resultados inesperados " . Esta resposta não se aplica ao C # ≥ 5.0 .

@ John Skeet e todos que preferem a palavra-chave foreach.

O problema com "foreach" em C # anterior à 5.0 é que ele é inconsistente com o modo como a "compreensão" equivalente funciona em outros idiomas e com o que eu esperaria que funcionasse (opinião pessoal declarada aqui apenas porque outros mencionaram seus opinião sobre legibilidade). Consulte todas as perguntas sobre " Acesso ao fechamento modificado " e " Variável sobre o loop considerada prejudicial ". Isso é apenas "prejudicial" devido à maneira como "foreach" é implementado em C #.

Pegue os exemplos a seguir, usando o método de extensão funcionalmente equivalente ao da resposta de @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);
        }
    }
}

Desculpas pelo exemplo excessivamente artificial. Só estou usando o Observable porque não é totalmente buscado fazer algo assim. Obviamente, existem maneiras melhores de criar isso observável, estou apenas tentando demonstrar um ponto. Normalmente, o código inscrito no observável é executado de forma assíncrona e potencialmente em outro encadeamento. Se usar "foreach", isso pode produzir resultados muito estranhos e potencialmente não determinísticos.

O seguinte teste usando o método de extensão "ForEach" passa:

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

O seguinte falha com o erro:

Esperado: equivalente a <0, 1, 2, 3, 4, 5, 6, 7, 8, 9> Mas foi: <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()));
}

Você pode usar a FirstOrDefault()extensão, que está disponível para IEnumerable<T>. Ao retornar falsedo predicado, ele será executado para cada elemento, mas não se importará em não encontrar uma correspondência. Isso evitará a ToList()sobrecarga.

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

Peguei o método de Fredrik e modifiquei o tipo de retorno.

Dessa forma, o método suporta execução adiada como outros métodos LINQ.

Edição: Se isso não ficou claro, qualquer uso desse método deve terminar com ToList () ou qualquer outra maneira de forçar o método a trabalhar no enumerável completo. Caso contrário, a ação não seria executada!

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

E aqui está o teste para ajudar a vê-lo:

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

Se você remover o ToList () no final, verá o teste falhando, pois o StringBuilder contém uma sequência vazia. Isso ocorre porque nenhum método forçou o ForEach a enumerar.

Mantenha seus efeitos colaterais fora do meu IEnumerable

Gostaria de fazer o equivalente ao seguinte no LINQ, mas não consigo descobrir como:

Como outros já apontaram aqui e no exterior, IEnumerableespera-se que o LINQ e os métodos sejam livres de efeitos colaterais.

Deseja realmente "fazer alguma coisa" para cada item no IEnumerable? Então foreaché a melhor escolha. As pessoas não ficam surpresas quando os efeitos colaterais acontecem aqui.

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

Aposto que você não quer um efeito colateral

No entanto, na minha experiência, efeitos colaterais geralmente não são necessários. Na maioria das vezes, existe uma consulta LINQ simples aguardando descoberta, acompanhada por uma resposta do StackOverflow.com por Jon Skeet, Eric Lippert ou Marc Gravell explicando como fazer o que você deseja!

Alguns exemplos

Se você está apenas agregando (acumulando) algum valor, considere o Aggregatemétodo de extensão.

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

Talvez você queira criar um novo a IEnumerablepartir dos valores existentes.

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

Ou talvez você queira criar uma tabela de consulta:

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

A lista (trocadilhos não totalmente intencionados) de possibilidades continua.

Se você deseja atuar como os rolos de enumeração, deve gerar cada item.

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

Existe uma versão experimental da Microsoft das extensões interativas para o LINQ (também no NuGet , consulte o perfil do RxTeams para obter mais links). O vídeo do Channel 9 explica bem.

Seus documentos são fornecidos apenas no formato XML. Eu executei esta documentação no Sandcastle para permitir que ela esteja em um formato mais legível. Descompacte o arquivo morto do docs e procure index.html .

Entre muitas outras vantagens, ele fornece a implementação ForEach esperada. Permite escrever código como este:

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

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

De acordo com o PLINQ (disponível desde .Net 4.0), você pode fazer uma

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

para executar um loop foreach paralelo em um IEnumerable.

O objetivo do ForEach é causar efeitos colaterais. IEnumerable é para enumeração lenta de um conjunto.

Essa diferença conceitual é bastante visível quando você a considera.

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

Isso não será executado até que você faça uma "contagem" ou um "ToList ()" ou algo assim. Claramente não é o que é expresso.

Você deve usar as extensões IEnumerable para configurar cadeias de iteração, definindo o conteúdo por suas respectivas fontes e condições. As árvores de expressão são poderosas e eficientes, mas você deve aprender a apreciar sua natureza. E não apenas para programar em torno deles para salvar alguns caracteres substituindo a avaliação preguiçosa.

Muitas pessoas mencionaram, mas eu tive que escrever. Isso não é mais claro / mais legível?

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

Curto e simples (st).

Agora temos a opção de ...

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

Obviamente, isso abre uma nova lata de threadworms.

ps (Desculpe pelas fontes, foi o que o sistema decidiu)

Como inúmeras respostas já apontam, você pode adicionar facilmente esse método de extensão. No entanto, se você não quiser fazer isso, embora eu não esteja ciente de algo assim na BCL, ainda há uma opção no Systemespaço para nome, se você já tiver uma referência à Extensão Reativa (e se não quiser). , Você devia ter):

using System.Reactive.Linq;

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

Embora os nomes dos métodos sejam um pouco diferentes, o resultado final é exatamente o que você está procurando.

O ForEach também pode ser acorrentado , basta retornar à linha de pilotos após a ação. permaneça fluente

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

Uma versão ansiosa da implementação.

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: um preguiçoso versão está usando retorno de rendimento, como este .

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

A versão Lazy PRECISA ser materializada, ToList () por exemplo, caso contrário, nada acontece. veja abaixo ótimos comentários de ToolmakerSteve.

IQueryable<Product> query = Products.Where(...);
query.ForEachLazy(t => t.Price = t.Price + 1.00)
    .ToList(); //without this line, below SubmitChanges() does nothing.
SubmitChanges();

Eu mantenho ForEach () e ForEachLazy () na minha biblioteca.

Essa abstração de "abordagem funcional" vaza muito tempo. Nada no nível do idioma evita efeitos colaterais. Contanto que você possa chamar seu lambda / delegado para cada elemento no contêiner - você obterá o comportamento "ForEach".

Aqui, por exemplo, uma maneira de mesclar srcDictionary em destDictionary (se a chave já existir - substitui)

isso é um hack e não deve ser usado em nenhum código de produção.

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

Inspirado por Jon Skeet, estendi sua solução com o seguinte:

Método de extensão:

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

Cliente:

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

O MoreLinq possui várias IEnumerable<T>.ForEachoutras extensões úteis. Provavelmente não vale a pena assumir a dependência apenas porForEach , mas há muitas coisas úteis lá.

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

https://github.com/morelinq/MoreLINQ

Eu discordo respeitosamente da noção de que os métodos de extensão de link devem ser livres de efeitos colaterais (não apenas porque não são, qualquer delegado pode executar efeitos colaterais).

Considere o seguinte:

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

O que o exemplo mostra é realmente apenas um tipo de ligação tardia que permite invocar uma das muitas ações possíveis com efeitos colaterais em uma sequência de elementos, sem precisar escrever uma grande construção de chave para decodificar o valor que define a ação e traduzir no seu método correspondente.

Para permanecer fluente, pode-se usar esse truque:

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

Para o VB.NET, você deve usar:

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

Mais um ForEachexemplo

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