Quel est le rôle de IEnumerable & lt; T & gt; et pourquoi devrais-je l'utiliser?

Sur ce point Jeffrey-Richter écrit:

Lors de la déclaration de la méthode des types de paramètres, vous devez spécifier le plus faible possible,
préférant les interfaces sur les classes de base. Par exemple, si vous écrivez une méthode qui
manipule une collection d'éléments, il serait préférable de déclarer la méthode du paramètre par
à l'aide d'une interface telle que IEnumerable<T> plutôt que d'utiliser un solide de type de données telles que List<T> ou même une forte type d'interface tels que ICollection<T> ou IList<T>:

//Desired: This method uses a weak parameter type   
public void ManipulateItems<T>(IEnumerable<T> collection) { ... }  

//Undesired: This method uses a strong parameter type   
public void ManipulateItems<T>(List<T> collection) { ... }

La raison, bien sûr, c'est que quelqu'un peut appeler la première méthode de passage dans un tableau d'objet, un List<T> objet, un String objet, et ainsi de suite — tout objet dont le type implémente IEnumerable<T>. La seconde méthode permet seulement List<T> objets à être passé; il n'accepte un tableau ou un String objet. Évidemment, la première méthode est préférable car il est plus souple et peut être utilisé dans un éventail beaucoup plus large de scénarios.

Naturellement, si vous écrivez une méthode qui nécessite une liste (pas n'importe quel objet énumérable), vous devez déclarer le type de paramètre comme un IList<T>. Vous devriez toujours éviter de déclarer le type de paramètre que List<T>. À l'aide de IList<T> permet à l'appelant de passer des tableaux et d'autres objets dont le type implémente IList<T>.

Sur le revers de la médaille, il est généralement préférable de déclarer une méthode de type de retour en utilisant le plus fort possible (en essayant de ne pas vous engager à un type spécifique).

En utilisant le concept de itérateurs vous pouvez obtenir une amélioration majeure de l'algorithme de la qualité, à la fois en termes de vitesse et l'utilisation de la mémoire.

Considérons les deux exemples de code suivants. À la fois analyser le fichier, on stocke les lignes de la collecte, les autres utilisations énumérable.

Premier exemple prend C * O(N) le temps et la mémoire O(N)

IEnumerable<string> lines = SelectLines();
List<Item> items = lines.Select(l=>ParseToItem(l)).ToList();
var itemOfIterest = items.FirstOrDefault(IsItemOfIterest); 

Deuxième exemple prend 1/2 C * O(N) le temps et la mémoire constante.

var itemOfIterest = lines.FirstOrDefault(l=>IsItemOfIterest(ParseToItem(l));

Voici le code de SelectLines()

 IEnumerable<string> SelectLines()
 {
  ...
  using(var reader = ...)
  while((line=reader.ReadLine())!=null)
   yield return line;
 }

Ici, c'est pourquoi 1/2 de temps. Disons que la probabilité de trouver l'élément à n'importe quelle position dans la gamme des fichiers est la même. En cas de IEnumerable, seules les lignes jusqu'à l'élément d'intérêt sera lu à partir du fichier. En cas de ToList appel au cours de la énumérable, tous les fichiers seront lus.

Bien sûr, la Liste contiendra tous les éléments en mémoire, c'est pourquoi O(N) l'utilisation de la mémoire.

Généralement vous n'utilisez pas IEunumerable directement. C'est la classe de base pour un certain nombre d'autres collections que vous êtes plus susceptibles d'utiliser. IEnumerablepar exemple, offre la possibilité de boucle à travers une collection avec foreach. Qui est utilisé par de nombreux héritant des classes comme List<T>. Mais IEnumerable n'offre pas une méthode de tri (bien que vous pouvez utiliser Linq pour cela), alors que certaines autres génériques collections comme List<T> à avoir cette méthode.

Oh, bien sûr, vous pouvez l'utiliser pour créer vos propres types de collection. Mais pour des trucs tous les jours, il n'est probablement pas utile que les collections qui en découlent.

Pourquoi mettre en place IEnumerable dans votre classe?

Si vous écrivez une classe, et la classe implémente l'interface IEnumerable (générique (T) ou non), vous êtes en permettant à tout consommateur de votre classe à parcourir sa collection sans savoir comment il est structuré.

Une LinkedList est mis en œuvre différemment d'une File d'attente, une Pile, un BinaryTree, une table de hachage, Graphique, etc. La collection représentée par votre classe pourrait être structuré de différentes façons.

Comme un "consommateur" (si vous écrivez une classe, et la classe consomme/fait usage d'une classe-objet qui implémente l'interface IEnumerable) vous pouvez l'utiliser sans se préoccuper de comment il est mis en œuvre. Parfois, les consommateurs de la classe ne se soucie pas de la mise en œuvre - il veut juste aller sur tous les éléments (impression? les changer? les comparer? etc.)

(Donc en tant que consommateur, si votre objectif est de parcourir tous les éléments dans un BinaryTree classe, et vous avez sauté cette leçon de Données-Structures-101 - si le BinaryTree codeur mise en œuvre de la IEnumberable - vous avez de la chance! Vous n'avez pas à ouvrir un livre et apprenez comment parcourir l'arbre - mais tout simplement utiliser l'instruction foreach sur cet objet et vous avez terminé.)

Comme un "producteur" (l'écriture d'une classe qui contient la structure des données/de la collection), vous pourriez ne pas vouloir les consommateurs de votre classe pour gérer la façon dont il est structuré (peur qu'ils pourraient casser, peut-être). Vous pouvez faire la collection privée, et seulement exposer un public IEnumerator.

Il peut aussi permettre une certaine uniformité, une collection peut avoir un peu de moyens pour effectuer une itération sur les éléments (Précommande, Afinde, PostOrder, Largeur, Profondeur du Premier, etc.) - mais il n'y a qu'1 de la mise en œuvre de IEnumerable. Vous pouvez utiliser cette fonction pour définir le "par défaut" afin de parcourir la collection.

Pourquoi utiliser IEnumerable dans votre méthode?

Si j'écris une méthode qui prend une collection, itère sur elle, et prend des mesures sur les éléments (les agréger? compare? etc.) pourquoi devrais-je me limiter à 1 type de collections?

L'écriture de cette méthode public void Sum(List<int> list) {...} de la somme de tous les éléments de la collection, les moyens, je ne peut recevoir une liste et une somme de plus de. L'écriture de ce public void Sum(IEnumerable<int> collection) {...} signifie que je peux prendre n'importe quel objet qui implémente IEnumberable (Listes, Files, Piles, etc.) et la somme de tous leurs éléments.

D'Autres Considérations

Il y a aussi les questions de l'exécution différée et des ressources non managées. IEnumerable faut utiliser du rendement de la syntaxe, ce qui signifie que vous passez sur chaque élément par lui-même et peut effectuer toutes sortes de calculs avant et après. Et encore une fois, cela se passe un par un, de sorte que vous n'avez pas à tenir toute la collection lorsque vous démarrez. Les calculs ne sera pas réellement être effectué jusqu'à ce que l'énumération commence (c'est à dire jusqu'à l'exécution de la boucle foreach). Et qui pourrait être utile et plus efficace dans certains cas. Par exemple, votre classe pourrait ne pas tenir toute la collection dans la mémoire, mais plutôt itérer sur tous les fichiers existant dans un certain répertoire, ou des éléments de certaines DB, ou d'autres ressources non managées. IEnumerable peut intervenir et de le faire pour vous (vous pouvez aussi le faire sans IEnumerable, mais IEnumberable "s'adapte" sur le plan conceptuel, plus il vous donne l'avantage de pouvoir utiliser l'objet produit dans une boucle foreach).

1. IEnumerable de prendre avantage de l'exécution différée, comme expliqué ici: IEnumerable vs la Liste de Ce qu'il faut Utiliser? Comment fonctionnent-ils?

2. IEnumerable activer la référence implicite de conversion pour les types de tableau qui connu comme la Covariance. Considérons l'exemple suivant:

public abstract class Véhicule
{
}

public class Car :Vehicle
{
}

private void doSomething1(IEnumerable<Vehicle> vehicles)
{

}

private void doSomething2(List<Vehicle> vehicles)
{

}

var vec = new List<Car>();
doSomething1(vec); //this is ok 
doSomething2(vec); //this will give a compilation error