foreach vs someList.ForEach(){}

Nous avons eu un peu de code ici (dans VS2005 et C#2.0) où le précédent ingénieurs sont sortis de leur manière d'utiliser list.ForEach( delegate(item) { foo;}); au lieu de foreach(item in list) {foo; }; pour tout le code qu'ils ont écrit. par exemple, un bloc de code pour la lecture des lignes à partir d'un dataReader.

Je ne sais toujours pas exactement pourquoi ils ont fait cela.

Les inconvénients de list.ForEach() sont:

• Il est plus prolixe en C# 2.0. Toutefois, en C# 3-delà, vous pouvez utiliser le bouton "=>" syntaxe pour faire bien laconique expressions.

• Il est moins familier. Les personnes qui ont à maintenir ce code me demande pourquoi vous l'avez fait de cette façon. Il m'a fallu un certain temps pour décider qu'il n'y avait aucune raison, sauf peut-être pour faire de l'écrivain judicieux (la qualité du reste du code sapé que). Il a également été moins lisible, avec le "})" à la fin du délégué bloc de code.

• Voir aussi le projet de Loi de Wagner livre "Effective C#: 50 Moyens Spécifiques pour Améliorer Votre C#", où il parle de pourquoi foreach est préféré à d'autres boucles comme pour la ou les boucles "while" - le point principal est que vous êtes de laisser le compilateur décider de la meilleure façon de construire la boucle. Si une future version du compilateur gère à utiliser une technique plus rapide, vous obtiendrez gratuitement en utilisant foreach et de reconstruction, plutôt que de changer votre code.

• un foreach(item in list) construire vous permet d'utiliser break ou continue si vous avez besoin de sortir de l'itération ou la boucle. Mais vous ne pouvez pas modifier la liste à l'intérieur d'une boucle foreach.

Je suis surpris de voir que list.ForEach est légèrement plus rapide. Mais ce n'est probablement pas une raison valable pour l'utiliser dans tout , que serait prématuré d'optimisation. Si votre application utilise une base de données ou un service web, pas de contrôle de la boucle, est presque toujours va être où le temps passe. Et avez-vous comparé par rapport à un for boucle de trop? Le list.ForEach pourrait être plus rapide en raison de l'aide qu'à l'interne et for boucle sans l'emballage serait encore plus rapide.

Je suis en désaccord que le list.ForEach(delegate) version est "la plus fonctionnelle" de manière significative. Il passe d'une fonction à une fonction, mais il n'y a pas de grande différence dans le résultat ou le programme de l'organisation.

Je ne pense pas que foreach(item in list) "dit exactement comment vous voulez qu'il fait" - un for(int 1 = 0; i < count; i++) boucle n'est qu'un foreach boucle laisse le choix de contrôler jusqu'à le compilateur.

Mon sentiment est sur un nouveau projet, d'utiliser foreach(item in list) pour la plupart des boucles pour adhérer à l'usage commun et pour des raisons de lisibilité, et l'utilisation list.Foreach() uniquement pour les blocs courts, quand vous pouvez faire quelque chose de plus élégamment ou de manière compacte avec le C# 3 "=>" de l'opérateur. Dans de tels cas, il peut y avoir une extension LINQ méthode est plus spécifique que ForEach(). Voir si Where(), Select(), Any(), All(), Max() ou une des nombreuses autres méthodes LINQ n'est pas déjà faire ce que vous voulez à partir de la boucle.

Je sais que les deux obscur-ish choses qui les rendent différents. Aller moi!

Tout d'abord, il y a le classique bug de faire un délégué pour chaque élément de la liste. Si vous utilisez le mot-clé foreach, tous vos délégués peuvent se référant au dernier élément de la liste:

    //A list of actions to execute later
    List<Action> actions = new List<Action>();

    //Numbers 0 to 9
    List<int> numbers = Enumerable.Range(0, 10).ToList();

    //Store an action that prints each number (WRONG!)
    foreach (int number in numbers)
        actions.Add(() => Console.WriteLine(number));

    //Run the actions, we actually print 10 copies of "9"
    foreach (Action action in actions)
        action();

    //So try again
    actions.Clear();

    //Store an action that prints each number (RIGHT!)
    numbers.ForEach(number =>
        actions.Add(() => Console.WriteLine(number)));

    //Run the actions
    foreach (Action action in actions)
        action();

La Liste.ForEach méthode n'ont pas ce problème. L'élément actuel de l'itération est passé par valeur, comme un argument à l'extérieur lambda, et puis l'intérieur lambda correctement saisit cet argument dans sa propre fermeture. Le problème est résolu.

(Malheureusement je crois ForEach est un membre de la Liste, plutôt qu'une extension de la méthode, mais il est facile de définir vous-même si vous disposez de cette installation sur toute énumérable type.)

Deuxièmement, l'approche de la méthode ForEach a une limitation. Si vous êtes à la mise en œuvre de IEnumerable en utilisant les taux de retour, vous ne pouvez pas faire un taux de retour à l'intérieur de la lambda. Donc à parcourir les éléments dans une collection pour obtenir le retour des choses n'est pas possible par cette méthode. Vous aurez à utiliser le mot-clé foreach et de travailler autour de la fermeture, le problème manuellement en faisant une copie de la boucle de courant de valeur à l'intérieur de la boucle.

Plus ici

Vous pouvez nommer le délégué anonyme 🙂

Et vous pouvez écrire le deuxième:

someList.ForEach(s => s.ToUpper())

Que je préfère, et permet d'économiser beaucoup de la dactylographie.

Que Joachim dit, le parallélisme est plus facile à appliquer à la deuxième forme.

Liste.ForEach() est considérée comme la plus fonctionnelle.

List.ForEach() dit ce que vous voulez faire. foreach(item in list) également dit exactement comment vous voulez qu'il fait. Cela laisse List.ForEach libre de changer la mise en œuvre de la comment part dans l'avenir. Par exemple, dans un futur hypothétique version de .Net peut toujours courir List.ForEach en parallèle, sous l'hypothèse que, à ce point, tout le monde a un nombre de cœurs de processeur qui sont généralement assis au ralenti.

D'autre part, foreach (item in list) vous donne un peu plus de contrôle sur la boucle. Par exemple, vous savez que les articles seront répétées dans un ordre séquentiel, et vous pourriez facilement percer dans le milieu si un élément qui répond à une certaine condition.

La deuxième façon, vous a montré utilise une extension de la méthode à exécuter la méthode du délégué pour chacun des éléments de la liste.

De cette façon, vous avez un autre délégué (=méthode) appel.

En outre, il ya la possibilité d'itérer la liste avec un pour boucle.

Le ForEach fonction membre de la classe générique List.

Que j'ai créé à la suite de l'extension de reproduire le code interne:

public static class MyExtension<T>
    {
        public static void MyForEach(this IEnumerable<T> collection, Action<T> action)
        {
            foreach (T item in collection)
                action.Invoke(item);
        }
    }

Donc à la fin, nous utilisons une normale foreach (ou une boucle pour si vous voulez).

Sur l'autre main, à l'aide d'une fonction de délégué est juste une autre façon de définir une fonction, ce code:

delegate(string s) {
    <process the string>
}

est équivalent à:

private static void myFunction(string s, <other variables...>)
{
   <process the string>
}

ou à l'aide de labda expressions:

(s) => <process the string>