Liste <T> .foreach par rapport à l'extension personnalisée IEnumerable <T>

Question

Dire que j'ai une classe:

public class MyClass 
{ 
    ... 
} 

et une méthode de webservice qui retourne un IEnumerable<MyClass>

Le consommateur du webservice définit une méthode:

Maintenant, le consommateur peut appeler le DoSomething sur le résultat de la méthode de service Web de deux façons:Maintenant, le consommateur peut appeler DoSomething sur le résultat de la méthode de service Web de deux manières:

var result = // web service call 

foreach(var myClass in result) 
{ 
    DoSomething(myClass); 
} 

ou:

var result = // web service call 

result.ToList().ForEach(DoSomething); 

Inutile de dire que je préfère de beaucoup la seconde manière, car il est beaucoup plus court et plus expressif (une fois que vous vous habituez à la syntaxe, que j'ai).

Maintenant, la méthode de service Web expose seulement une IEnumerable<MyClass>, mais il retourne en fait un List<MyClass> qui (AFAIK) signifie que l'objet sérialisé réelle est encore un List<T>. Cependant, j'ai trouvé (en utilisant le réflecteur) que la méthode Linq ToList() fait une copie de tous les objets dans le IEnumerable<T> quel que soit le type d'exécution réel (à mon avis, il pourrait avoir casté l'argument à un List<T> s'il était déjà un).

Cela a évidemment un certain surcoût de performance, en particulier pour les grandes listes (ou les listes d'objets volumineux).

Alors, que puis-je faire pour résoudre ce problème, et pourquoi n'y a-t-il pas de méthode ForEach dans Linq? Par ailleurs, sa question est vaguement liée à this one.

Answer 1

J'utilise 2 méthodes. On itère la liste, on travaille avec eval paresseux. Je les utilise comme la situation définit.

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

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

Answer 2

Vous pouvez écrire votre propre méthode d'extension pour IEnumerable<T> comme ceci:

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

Une telle méthode n'est pas présent dans Linq, parce que Linq est essentiellement destiné aux requêtes, et non pour des itérations simples. Notez également que lors de l'utilisation d'une instance réelle List<T>, la méthode d'extension ne sera pas appelée car les méthodes d'instance ont la priorité sur les méthodes d'extension lorsqu'elles partagent la signature.

Le code suivant, par exemple, ne serait pas invoquer la méthode d'extension:

var l = new List<MyClass>(); 
l.Add(new MyClass()); 
l.ForEach(DoSomething); 

Alors que les suivantes seraient:

IEnumerable<MyClass> l = new List<MyClass>(new []{new MyClass()}); 
l.ForEach(DoSomething); 

Answer 3

Vous pouvez écrire une méthode d'extension, mais il y a good reasons pourquoi ForEach est pas implémenté sur IEnumerable<T>. Le second exemple

result.ToList().ForEach(DoSomething); 

copie le IEnumerable dans une liste (sauf si elle est déjà une liste, je suppose) donc vous êtes mieux juste itérer IEnumerable avec un bon vieux foreach(var r in result) {}.

Addendum:

Pour moi, le point clé de l'article d'Eric Lippert est que l'ajout ForEach n'a aucun avantage et ajoute quelques pièges potentiels:

La deuxième raison est que faire si ajouts zéro nouvelle pouvoir de représentation à la langue. En faisant cela, vous pouvez réécrire ce code parfaitement clair:

foreach (Foo toto in foos) {déclaration impliquant foo; }

dans ce code:

foos.ForEach ((Foo foo) => {statement impliquant foo;});

qui utilise presque exactement les mêmes caractères dans l'ordre légèrement différent . Et pourtant la deuxième version est plus difficile à comprendre, plus difficile à déboguer, et introduit la sémantique de fermeture, ainsi potentiellement changer l'objet vies de manière subtile.

Answer 4

Je préférerais ceci: -

foreach (var item in result.ToList()) 
{ 
    DoSomething(item); 
} 

Son beaucoup plus clair idiome, il est dit recueillir une liste de choses ensemble puis faire quelque chose d'important qui peut changer l'état de l'application. Son ancienne école mais cela fonctionne et est en fait plus compréhensible à un public plus large.

Answer 5

Si vous décidez de le faire via une méthode d'extension, je l'appellerais ForAll au lieu de ForEach. Ceci afin d'utiliser la même syntaxe que l'utilisation Parallel Extensions in .NET 4.0:

var result = // web service call 
result.AsParallel().ForAll(DoSomething); 

Answer 6

Vous pouvez écrire votre propre méthode d'extension ToList (cette liste theList) {return theList;} et éviter la surcharge. Puisque votre méthode d'extension est la plus spécifique, elle sera appelée, pas celle sur IEnumerable