Équivalent LINQ de foreach pour IEnumerable<T>

Question

J'aimerais faire l'équivalent de ce qui suit en LINQ, mais je n'arrive pas à comprendre comment :

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

Quelle est la véritable syntaxe ?

Answer 1

Il n'y a pas d'extension ForEach pour IEnumerable ; uniquement pour les List<T> . Vous pouvez donc faire

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

Vous pouvez également écrire votre propre méthode d'extension ForEach :

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

Answer 2

Fredrik a fourni le correctif, mais il peut être utile de se demander pourquoi cela ne figure pas dans le cadre dès le départ. Je pense que l'idée est que les opérateurs de requête LINQ devraient être sans effet de bord, s'intégrant dans une manière raisonnablement fonctionnelle de voir le monde. Il est clair que ForEach est exactement le contraire - un purement une construction basée sur les effets secondaires.

Cela ne veut pas dire qu'il s'agit d'une mauvaise chose à faire - il s'agit simplement de réfléchir aux raisons philosophiques qui sous-tendent cette décision.

Answer 3

Mise à jour 7/17/2012 : Apparemment, à partir de C# 5.0, le comportement de foreach décrite ci-dessous a été modifiée et " l'utilisation d'un foreach dans une expression lambda imbriquée ne produit plus de résultats inattendus. " Cette réponse ne s'applique pas à C# 5.0.

@John Skeet et tous ceux qui préfèrent le mot-clé foreach.

Le problème avec "foreach" en C# avant la version 5.0 L'opinion personnelle exprimée ici, uniquement parce que d'autres ont mentionné leur opinion concernant la lisibilité, est qu'elle n'est pas cohérente avec la manière dont l'équivalent "pour la compréhension" fonctionne dans d'autres langues, et avec la manière dont je m'attendrais à ce qu'il fonctionne. Voir toutes les questions concernant " Accès à une fermeture modifiée " ainsi que " La fermeture de la variable de la boucle est considérée comme nuisible ". Cette situation n'est "préjudiciable" qu'en raison de la manière dont "foreach" est mis en œuvre en C#.

Prenez les exemples suivants en utilisant la méthode d'extension fonctionnellement équivalente à celle de la réponse 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);
        }
    }
}

Je m'excuse pour cet exemple trop artificiel. Je n'utilise Observable que parce que ce n'est pas complètement farfelu de faire quelque chose comme ça. Il est évident qu'il y a de meilleures façons de créer cet observable, j'essaie seulement de démontrer un point. Typiquement, le code souscrit à l'observable est exécuté de manière asynchrone et potentiellement dans un autre thread. Si l'on utilise "foreach", cela pourrait produire des résultats très étranges et potentiellement non déterministes.

Le test suivant, qui utilise la méthode d'extension "ForEach", est réussi :

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

L'opération suivante échoue avec l'erreur :

Attendu : équivalent à < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 > Mais c'était le cas : < 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()));
}

Answer 4

Vous pouvez utiliser le FirstOrDefault() qui est disponible pour les IEnumerable<T> . En renvoyant false du prédicat, il sera exécuté pour chaque élément mais ne se souciera pas du fait qu'il ne trouve pas de correspondance. Cela permet d'éviter le problème de la ToList() de la tête.

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

Answer 5

J'ai repris la méthode de Fredrik et j'ai modifié le type de retour.

De cette manière, la méthode prend en charge exécution différée comme les autres méthodes LINQ.

EDITAR: Si cela n'était pas clair, toute utilisation de cette méthode doit se terminer par ToList() ou tout autre moyen de forcer la méthode à fonctionner sur l'énumérable complet. Dans le cas contraire, l'action ne serait pas exécutée !

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

Et voici le test qui permet de s'en rendre compte :

[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 vous retirez le ToList() à la fin, vous verrez que le test échoue car le StringBuilder contient une chaîne vide. C'est parce qu'aucune méthode n'a forcé le ForEach à énumérer.