Équivalent LINQ de foreach pour IEnumerable <T>

Je voudrais faire l'équivalent de ce qui suit dans LINQ, mais je ne peux pas comprendre comment:

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

Quelle est la vraie syntaxe?

Il n'y a pas d'extension ForEach pour IEnumerable; seulement pour List<T>. Donc tu pourrais faire

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

Sinon, écrivez 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);
    }
}

Fredrik a fourni le correctif, mais il vaut peut-être la peine de se demander pourquoi ce n'est pas dans le cadre pour commencer. Je crois que l'idée est que les opérateurs de requête LINQ devraient être sans effet secondaire, s'inscrivant dans une manière raisonnablement fonctionnelle de regarder le monde. Clairement, ForEach est exactement le contraire - une construction purement basée sur les effets secondaires.

Cela ne veut pas dire que c'est une mauvaise chose à faire - il suffit de penser aux raisons philosophiques derrière la décision.

Mise à jour 17/07/2012: Apparemment à partir de C # 5.0, le comportement de foreachdécrit ci-dessous a été modifié et « l'utilisation d'une foreachvariable d'itération 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 5.0 , c'est qu'il est incompatible avec le fonctionnement de l'équivalent "pour la compréhension" dans d'autres langues, et avec la façon dont je m'attendrais à ce qu'il fonctionne (opinion personnelle indiquée ici uniquement parce que d'autres ont mentionné leur opinion sur la lisibilité). Voir toutes les questions concernant " Accès à la fermeture modifiée " ainsi que " Fermeture sur la variable de boucle considérée comme nuisible ". Ceci n'est "nuisible" qu'en raison de la façon dont "foreach" est implémenté 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);
        }
    }
}

Toutes mes excuses pour l'exemple trop artificiel. J'utilise uniquement Observable parce que ce n'est pas totalement exagéré de faire quelque chose comme ça. Évidemment, il existe de meilleures façons de créer cet observable, j'essaie seulement de démontrer un point. En règle générale, le code souscrit à l'observable est exécuté de manière asynchrone et potentiellement dans un autre thread. Si vous utilisez "foreach", cela pourrait produire des résultats très étranges et potentiellement non déterministes.

Le test suivant utilisant la méthode d'extension "ForEach" réussit:

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

Ce qui suit échoue avec l'erreur:

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

Vous pouvez utiliser l' FirstOrDefault()extension, qui est disponible pour IEnumerable<T>. En revenant falsedu prédicat, il sera exécuté pour chaque élément mais ne se souciera pas qu'il ne trouve pas réellement de correspondance. Cela évitera les ToList()frais généraux.

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

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

De cette façon, la méthode prend en charge l' exécution différée comme les autres méthodes LINQ.

EDIT: Si cela n'était pas clair, toute utilisation de cette méthode doit se terminer par ToList () ou toute autre façon de forcer la méthode à travailler sur l'énumérable complet. Sinon, l'action ne serait pas effectué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 pour vous aider à le voir:

[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 supprimez la ToList () à la fin, vous verrez le test échouer puisque le StringBuilder contient une chaîne vide. En effet, aucune méthode n'a forcé ForEach à énumérer.

Gardez vos effets secondaires hors de mon IEnumerable

Je voudrais faire l'équivalent de ce qui suit dans LINQ, mais je ne peux pas comprendre comment:

Comme d'autres l'ont souligné ici et à l'étranger, LINQ et les IEnumerableméthodes devraient être exemptes d'effets secondaires.

Voulez-vous vraiment "faire quelque chose" pour chaque élément de l'IEnumerable? C'est alors foreachle meilleur choix. Les gens ne sont pas surpris lorsque des effets secondaires se produisent ici.

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

Je parie que tu ne veux pas d'effets secondaires

Cependant, d'après mon expérience, les effets secondaires ne sont généralement pas nécessaires. Le plus souvent, il y a une simple requête LINQ à découvrir, accompagnée d'une réponse StackOverflow.com de Jon Skeet, Eric Lippert ou Marc Gravell expliquant comment faire ce que vous voulez!

Quelques exemples

Si vous êtes en train d'agréger (d'accumuler) une certaine valeur, vous devriez envisager la Aggregateméthode d'extension.

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

Vous souhaitez peut-être en créer un nouveau à IEnumerablepartir des valeurs existantes.

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

Ou peut-être souhaitez-vous créer une table de correspondance:

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

La liste (jeu de mots pas entièrement destiné) de possibilités s'allonge encore et encore.

Si vous voulez agir comme rouleaux d'énumération, vous devez rapporter chaque élément.

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

Il existe une version expérimentale par Microsoft des extensions interactives à LINQ (également sur NuGet , voir le profil de RxTeams pour plus de liens). La vidéo de Channel 9 l' explique bien.

Ses documents sont uniquement fournis au format XML. J'ai exécuté cette documentation à Sandcastle pour lui permettre d'être dans un format plus lisible. Décompressez l'archive des documents et recherchez index.html .

Parmi de nombreux autres avantages, il fournit l'implémentation ForEach attendue. Il vous permet d'écrire du code comme ceci:

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

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

Selon PLINQ (disponible depuis .Net 4.0), vous pouvez faire un

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

faire une boucle foreach parallèle sur un IEnumerable.

Le but de ForEach est de provoquer des effets secondaires. IEnumerable sert à l'énumération paresseuse d'un ensemble.

Cette différence conceptuelle est bien visible quand on y réfléchit.

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

Cela ne s'exécutera pas jusqu'à ce que vous fassiez un "count" ou un "ToList ()" ou quelque chose dessus. Ce n'est clairement pas ce qui est exprimé.

Vous devez utiliser les extensions IEnumerable pour configurer des chaînes d'itération, définissant le contenu par leurs sources et conditions respectives. Les arbres d'expression sont puissants et efficaces, mais vous devez apprendre à apprécier leur nature. Et pas seulement pour la programmation autour d'eux afin de sauvegarder quelques caractères remplaçant l'évaluation paresseuse.

Beaucoup de gens l'ont mentionné, mais j'ai dû l'écrire. N'est-ce pas le plus clair / le plus lisible?

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

Court et simple (st).

Maintenant, nous avons la possibilité de ...

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

Bien sûr, cela ouvre une toute nouvelle boîte de ténias.

ps (Désolé pour les polices, c'est ce que le système a décidé)

Comme de nombreuses réponses le soulignent déjà, vous pouvez facilement ajouter vous-même une telle méthode d'extension. Cependant, si vous ne voulez pas faire cela, bien que je ne sois pas au courant de quelque chose comme ça dans la BCL, il y a toujours une option dans l' Systemespace de noms, si vous avez déjà une référence à Reactive Extension (et si vous ne le faites pas , tu aurais dû):

using System.Reactive.Linq;

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

Bien que les noms de méthode soient un peu différents, le résultat final est exactement ce que vous recherchez.

ForEach peut également être enchaîné , il suffit de le remettre sur le pileline après l'action. rester fluide

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

Une version d'implémentation désireuse .

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: une version Lazy utilise return return, comme ceci .

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

La version Lazy a besoin d'être matérialisée, ToList () par exemple, sinon, rien ne se passe. voir ci-dessous d'excellents commentaires 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();

Je garde à la fois ForEach () et ForEachLazy () dans ma bibliothèque.

Cette abstraction "d'approche fonctionnelle" fuit beaucoup. Rien au niveau de la langue n'empêche les effets secondaires. Tant que vous pouvez le faire appeler votre lambda / délégué pour chaque élément du conteneur - vous obtiendrez le comportement "ForEach".

Voici par exemple une façon de fusionner srcDictionary en destDictionary (si la clé existe déjà - écrase)

c'est un hack, et ne doit être utilisé dans aucun code de production.

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

Inspiré par Jon Skeet, j'ai étendu sa solution avec les éléments suivants:

Méthode d'extension:

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

Client:

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 a IEnumerable<T>.ForEachet une tonne d'autres extensions utiles. Cela ne vaut probablement pas la peine de prendre la dépendance uniquement ForEach, mais il y a beaucoup de choses utiles là-dedans.

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

https://github.com/morelinq/MoreLINQ

Je suis en désaccord avec la notion selon laquelle les méthodes d'extension de lien devraient être sans effet secondaire (non seulement parce qu'elles ne le sont pas, tout délégué peut effectuer des effets secondaires).

Considérer ce qui suit:

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

Ce que l'exemple montre est vraiment juste une sorte de liaison tardive qui permet d'invoquer l'une des nombreuses actions possibles ayant des effets secondaires sur une séquence d'éléments, sans avoir à écrire une construction de gros commutateur pour décoder la valeur qui définit l'action et traduire dans sa méthode correspondante.

Pour rester fluide, on peut utiliser une telle astuce:

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

Pour VB.NET, vous devez utiliser:

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

Encore un autre ForEachexemple

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