IEnumerable vs Liste - Que faut-il utiliser ? Comment fonctionnent-ils ?

Question

J'ai quelques doutes sur le fonctionnement des énumérateurs et de LINQ. Considérons ces deux sélections simples :

List<Animal> sel = (from animal in Animals 
                    join race in Species
                    on animal.SpeciesKey equals race.SpeciesKey
                    select animal).Distinct().ToList();

ou

IEnumerable<Animal> sel = (from animal in Animals 
                           join race in Species
                           on animal.SpeciesKey equals race.SpeciesKey
                           select animal).Distinct();

J'ai changé les noms de mes objets originaux pour que cela ressemble à un exemple plus générique. La requête elle-même n'est pas si importante. Ce que je veux demander est ceci :

foreach (Animal animal in sel) { /*do stuff*/ }

1. J'ai remarqué que si j'utilise IEnumerable Lorsque je débogue et que j'inspecte "sel", qui dans ce cas est le IEnumerable, il possède quelques membres intéressants : "inner", "outer", "innerKeySelector" et "outerKeySelector", ces deux derniers semblent être des délégués. Le membre "inner" ne contient pas d'instances "Animal", mais plutôt des instances "Species", ce qui est très étrange pour moi. Le membre "outer" contient des instances "Animal". Je présume que les deux délégués déterminent ce qui entre et ce qui sort de ce membre ?

2. J'ai remarqué que si j'utilise "Distinct", l'élément "inner" contient 6 éléments (ce qui est incorrect car seuls 2 sont Distinct), mais l'élément "outer" contient les valeurs correctes. Encore une fois, ce sont probablement les méthodes déléguées qui déterminent cela, mais c'est un peu plus que ce que je connais de IEnumerable.

3. Plus important encore, laquelle des deux options est la plus performante ?

La conversion de la Liste du mal via .ToList() ?

Ou peut-être en utilisant directement l'énumérateur ?

Si vous le pouvez, veuillez également expliquer un peu ou fournir des liens qui expliquent cette utilisation de IEnumerable.

Answer 1

IEnumerable décrit un comportement, tandis que List est une mise en œuvre de ce comportement. Lorsque vous utilisez IEnumerable vous donnez au compilateur la possibilité de reporter le travail à plus tard, en l'optimisant éventuellement en cours de route. Si vous utilisez ToList(), vous forcez le compilateur à réifier les résultats tout de suite.

Chaque fois que je "empile" des expressions LINQ, j'utilise IEnumerable En effet, en spécifiant uniquement le comportement, je donne à LINQ une chance de différer l'évaluation et éventuellement d'optimiser le programme. Vous vous souvenez que LINQ ne génère pas le SQL pour interroger la base de données avant que vous ne l'ayez énumérée ? Considérez ceci :

public IEnumerable<Animals> AllSpotted()
{
    return from a in Zoo.Animals
           where a.coat.HasSpots == true
           select a;
}

public IEnumerable<Animals> Feline(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Felidae"
           select a;
}

public IEnumerable<Animals> Canine(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Canidae"
           select a;
}

Vous avez maintenant une méthode qui sélectionne un échantillon initial ("AllSpotted"), plus quelques filtres. Donc maintenant vous pouvez faire ceci :

var Leopards = Feline(AllSpotted());
var Hyenas = Canine(AllSpotted());

Il est donc plus rapide d'utiliser List plutôt que IEnumerable ? Seulement si vous voulez empêcher qu'une requête soit exécutée plus d'une fois. Mais est-ce mieux dans l'ensemble ? Eh bien, dans l'exemple ci-dessus, les Léopards et les Hyènes sont convertis en des requêtes SQL uniques pour chaque et la base de données ne renvoie que les lignes qui sont pertinentes. Mais si nous avions renvoyé une liste à partir de AllSpotted() Dans ce cas, l'exécution peut être plus lente, car la base de données peut renvoyer beaucoup plus de données que nécessaire, et nous perdons des cycles à effectuer le filtrage dans le client.

Dans un programme, il peut être préférable de reporter la conversion de votre requête en liste jusqu'à la toute fin, donc si je dois énumérer les Léopards et les Hyènes plus d'une fois, je ferais ceci :

List<Animals> Leopards = Feline(AllSpotted()).ToList();
List<Animals> Hyenas = Canine(AllSpotted()).ToList();

Answer 2

Une classe qui implémente IEnumerable vous permet d'utiliser le foreach la syntaxe.

En gros, il a une méthode pour obtenir l'élément suivant dans la collection. Il n'a pas besoin que la collection entière soit en mémoire et ne sait pas combien d'éléments elle contient, foreach continue juste à obtenir le prochain article jusqu'à ce qu'il soit épuisé.

Cela peut être très utile dans certaines circonstances, par exemple dans une table de base de données massive, vous ne voulez pas copier l'ensemble en mémoire avant de commencer à traiter les lignes.

Maintenant List met en œuvre IEnumerable mais représente l'ensemble de la collection en mémoire. Si vous avez une IEnumerable et vous appelez .ToList() vous créez une nouvelle liste avec le contenu de l'énumération en mémoire.

Votre expression linq renvoie une énumération et, par défaut, l'expression s'exécute lorsque vous effectuez une itération à l'aide de la commande foreach . Un site IEnumerable L'instruction linq s'exécute lorsque vous itérez le fichier foreach mais vous pouvez le forcer à itérer plus tôt en utilisant .ToList() .

Voilà ce que je veux dire :

var things = 
    from item in BigDatabaseCall()
    where ....
    select item;

// this will iterate through the entire linq statement:
int count = things.Count();

// this will stop after iterating the first one, but will execute the linq again
bool hasAnyRecs = things.Any();

// this will execute the linq statement *again*
foreach( var thing in things ) ...

// this will copy the results to a list in memory
var list = things.ToList()

// this won't iterate through again, the list knows how many items are in it
int count2 = list.Count();

// this won't execute the linq statement - we have it copied to the list
foreach( var thing in list ) ...

Answer 3

La chose la plus importante à comprendre est que, avec Linq, la requête n'est pas évaluée immédiatement. Elle n'est exécutée que dans le cadre de l'itération de l'ensemble des résultats de la requête. IEnumerable<T> dans un foreach - c'est ce que font tous les délégués bizarres.

Ainsi, le premier exemple évalue la requête immédiatement en appelant ToList et de mettre les résultats de la requête dans une liste.
Le deuxième exemple renvoie un IEnumerable<T> qui contient toutes les informations nécessaires pour exécuter la requête par la suite.

En termes de performances, la réponse est cela dépend . Si vous avez besoin que les résultats soient évalués en une seule fois (par exemple, si vous modifiez les structures que vous interrogez par la suite, ou si vous ne voulez pas que l'itération sur l'objet IEnumerable<T> pour prendre beaucoup de temps) utiliser une liste. Sinon, utilisez un IEnumerable<T> . Par défaut, il convient d'utiliser l'évaluation à la demande dans le deuxième exemple, car elle utilise généralement moins de mémoire, à moins qu'il n'y ait une raison spécifique de stocker les résultats dans une liste.

Answer 4

L'avantage de IEnumerable est l'exécution différée (généralement avec les bases de données). La requête ne sera pas exécutée tant que vous n'aurez pas bouclé les données. C'est une requête qui attend jusqu'à ce qu'elle soit nécessaire (aka lazy loading).

Si vous appelez ToList, la requête sera exécutée, ou "matérialisée" comme j'aime à le dire.

Il y a du pour et du contre dans les deux cas. Si vous appelez ToList, vous pouvez lever une partie du mystère quant au moment où la requête est exécutée. Si vous vous en tenez à IEnumerable, vous avez l'avantage que le programme n'effectue aucun travail avant d'en avoir besoin.

Answer 5

Si tout ce que vous voulez faire est de les énumérer, utilisez la fonction IEnumerable .

Attention, cependant, la modification de la collection originale à énumérer est une opération dangereuse - dans ce cas, vous voudrez ToList premier. Cela créera un nouvel élément de liste pour chaque élément en mémoire, en énumérant les éléments suivants IEnumerable et est donc moins performant si vous n'effectuez qu'une seule énumération - mais plus sûr et parfois le List sont pratiques (par exemple dans l'accès aléatoire).