LINQ equivalente de foreach para IEnumerable <T>

Me gustaría hacer el equivalente de lo siguiente en LINQ, pero no puedo entender cómo:

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

¿Cuál es la sintaxis real?

No hay extensión ForEach para IEnumerable; sólo para List<T>. Entonces podrías hacer

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

Alternativamente, escriba su propio método de extensión ForEach:

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

Fredrik ha proporcionado la solución, pero puede valer la pena considerar por qué esto no está en el marco para empezar. Creo que la idea es que los operadores de consulta LINQ no deberían tener efectos secundarios, y que se ajusten a una forma razonablemente funcional de ver el mundo. Claramente, ForEach es exactamente lo contrario: una construcción puramente basada en efectos secundarios.

Eso no quiere decir que sea algo malo, solo pensar en las razones filosóficas detrás de la decisión.

Actualización 17/07/2012: Aparentemente a partir de C # 5.0, el comportamiento foreachdescrito a continuación ha cambiado y " el uso de una foreachvariable de iteración en una expresión lambda anidada ya no produce resultados inesperados " . Esta respuesta no se aplica a C # ≥ 5.0 .

@John Skeet y todos los que prefieren la palabra clave foreach.

El problema con "foreach" en C # anterior a 5.0 , es que es inconsistente con la forma en que el equivalente "para la comprensión" funciona en otros idiomas, y con cómo esperaría que funcionara (la opinión personal aquí se menciona solo porque otros han mencionado su opinión sobre la legibilidad). Consulte todas las preguntas sobre " Acceso al cierre modificado ", así como " Cierre sobre la variable de bucle considerado dañino ". Esto es solo "dañino" debido a la forma en que se implementa "foreach" en C #.

Tome los siguientes ejemplos utilizando el método de extensión funcionalmente equivalente al de la respuesta 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);
        }
    }
}

Disculpas por el ejemplo excesivamente inventado. Solo estoy usando Observable porque no es del todo descabellado hacer algo como esto. Obviamente, hay mejores formas de crear este observable, solo estoy tratando de demostrar un punto. Por lo general, el código suscrito al observable se ejecuta de forma asíncrona y potencialmente en otro hilo. Si usa "foreach", esto podría producir resultados muy extraños y potencialmente no deterministas.

La siguiente prueba con el método de extensión "ForEach" pasa:

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

Lo siguiente falla con el error:

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

Puede usar la FirstOrDefault()extensión, que está disponible para IEnumerable<T>. Al regresar falsedel predicado, se ejecutará para cada elemento, pero no le importará que en realidad no encuentre una coincidencia. Esto evitará los ToList()gastos generales.

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

Tomé el método de Fredrik y modifiqué el tipo de retorno.

De esta manera, el método admite la ejecución diferida como otros métodos LINQ.

EDITAR: Si esto no estaba claro, cualquier uso de este método debe terminar con ToList () o cualquier otra forma de forzar el método para que funcione en el enumerable completo. De lo contrario, la acción no se realizaría.

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

Y aquí está la prueba para ayudar a verlo:

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

Si elimina ToList () al final, verá que la prueba falla ya que StringBuilder contiene una cadena vacía. Esto se debe a que ningún método obligó a ForEach a enumerar.

Mantenga sus efectos secundarios fuera de mi IEnumerable

Me gustaría hacer el equivalente de lo siguiente en LINQ, pero no puedo entender cómo:

Como otros han señalado aquí y en el extranjero IEnumerable, se espera que LINQ y los métodos estén libres de efectos secundarios.

¿Realmente quiere "hacer algo" a cada elemento en el IEnumerable? Entonces foreaches la mejor opción. La gente no se sorprende cuando ocurren efectos secundarios aquí.

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

Apuesto a que no quieres un efecto secundario

Sin embargo, en mi experiencia, generalmente no se requieren efectos secundarios. La mayoría de las veces hay una simple consulta LINQ esperando ser descubierta acompañada de una respuesta de StackOverflow.com de Jon Skeet, Eric Lippert o Marc Gravell que explica cómo hacer lo que quiere.

Algunos ejemplos

Si en realidad solo está agregando (acumulando) algún valor, entonces debe considerar el Aggregatemétodo de extensión.

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

Quizás desee crear uno nuevo a IEnumerablepartir de los valores existentes.

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

O tal vez desee crear una tabla de búsqueda:

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

La lista (juego de palabras no del todo previsto) de posibilidades sigue y sigue.

Si desea actuar como las listas de enumeración, debe ceder cada elemento.

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

Hay una versión experimental de Microsoft de Interactive Extensions para LINQ (también en NuGet , consulte el perfil de RxTeams para obtener más enlaces). El video del Canal 9 lo explica bien.

Sus documentos solo se proporcionan en formato XML. He ejecutado esta documentación en Sandcastle para permitir que esté en un formato más legible. Descomprima el archivo de documentos y busque index.html .

Entre muchas otras cosas, proporciona la implementación esperada de ForEach. Te permite escribir código como este:

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

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

Según PLINQ (disponible desde .Net 4.0), puede hacer un

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

hacer un bucle foreach paralelo en un IEnumerable.

El propósito de ForEach es causar efectos secundarios. IEnumerable es para la enumeración diferida de un conjunto.

Esta diferencia conceptual es bastante visible cuando la consideras.

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

Esto no se ejecutará hasta que haga un "conteo" o una "Lista ()" o algo así. Claramente no es lo que se expresa.

Debe usar las extensiones IEnumerable para configurar cadenas de iteración, definiendo el contenido por sus respectivas fuentes y condiciones. Los árboles de expresión son poderosos y eficientes, pero debes aprender a apreciar su naturaleza. Y no solo para programar a su alrededor para salvar algunos caracteres que anulan la evaluación perezosa.

Mucha gente lo mencionó, pero tuve que escribirlo. ¿No es esto más claro / más legible?

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

Corto y simple (st).

Ahora tenemos la opción de ...

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

Por supuesto, esto abre una nueva lata de gusanos de hilo.

ps (Perdón por las fuentes, es lo que decidió el sistema)

Como ya señalan numerosas respuestas, usted mismo puede agregar fácilmente dicho método de extensión. Sin embargo, si no desea hacer eso, aunque no estoy al tanto de algo así en el BCL, todavía hay una opción en el Systemespacio de nombres, si ya tiene una referencia a la Extensión reactiva (y si no , Deberías):

using System.Reactive.Linq;

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

Aunque los nombres de los métodos son un poco diferentes, el resultado final es exactamente lo que está buscando.

ForEach también se puede encadenar , solo vuelve a ponerlo en la pila después de la acción. mantener fluidez

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

Una versión ansiosa de implementación.

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
}

Editar: una versión perezosa está utilizando rendimiento de rendimiento, 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;
    }
}

La versión Lazy NECESITA materializarse, ToList () por ejemplo, de lo contrario, no pasa nada. vea abajo los excelentes comentarios 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();

Mantengo ForEach () y ForEachLazy () en mi biblioteca.

Esta abstracción de "enfoque funcional" se escapa a lo grande. Nada en el nivel del idioma previene los efectos secundarios. Siempre que pueda hacer que llame a su lambda / delegado para cada elemento en el contenedor, obtendrá el comportamiento "ForEach".

Aquí, por ejemplo, una forma de fusionar srcDictionary en destDictionary (si la clave ya existe, se sobrescribe)

Este es un truco y no debe utilizarse en ningún código de producción.

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

Inspirado por Jon Skeet, he ampliado su solución con lo siguiente:

Método de extensión:

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

MoreLinq tiene IEnumerable<T>.ForEachy un montón de otras extensiones útiles. Probablemente no valga la pena tomar la dependencia solo por ForEach, pero hay muchas cosas útiles allí.

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

https://github.com/morelinq/MoreLINQ

Estoy totalmente en desacuerdo con la idea de que los métodos de extensión de enlace deben estar libres de efectos secundarios (no solo porque no lo están, cualquier delegado puede realizar efectos secundarios).

Considera lo siguiente:

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

Lo que muestra el ejemplo es realmente un tipo de enlace tardío que permite invocar una de las muchas acciones posibles que tienen efectos secundarios en una secuencia de elementos, sin tener que escribir una construcción de interruptor grande para decodificar el valor que define la acción y traducir en su método correspondiente.

Para mantenerse fluido, uno puede usar un truco así:

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

Para VB.NET debes usar:

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

Otro ForEachejemplo

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