Linq: Quelle est la différence entre Select et Where

Les méthodes Select et Where sont disponibles dans Linq. Que doit savoir chaque développeur sur ces deux méthodes? Par exemple: quand utiliser l’un sur l’autre, quel avantage d’utiliser l’un sur l’autre, etc.

trouve les éléments qui correspondent et ne retourne que ceux qui le font ( filtrage ).

-> IEnumerable in, IEnumerable out

Sélectionner

renvoie quelque chose pour tous les éléments de la source ( projection / transformation ). Que quelque chose pourrait être les objects eux-mêmes, mais sont plus généralement une projection quelconque.

-> IEnumerable in, IEnumerable out

Select et Where sont deux opérateurs complètement différents agissant sur IEnumerable s.

Le premier est ce que nous appelons un opérateur de projection , tandis que le dernier est un opérateur de ressortingction .

Une manière intéressante d’avoir une idée du comportement de ces opérateurs consiste à examiner leur “type fonctionnel”.

  • Sélectionnez: (IEnumerable , Func ) → IEnumerable ; il prend en entrée à la fois un IEnumerable contenant des éléments de type T1 et une fonction transformant des éléments de type T1 en éléments de type T2. La sortie est un IEnumerable contenant des éléments de type T2.

    À partir de cela, on peut facilement deviner que cet opérateur produira sa sortie en appliquant la fonction d’entrée sur chaque élément de l’entrée IEnumerable et en encapsulant les résultats dans un nouvel IEnumerable.

    En utilisant une notation de type mathématique, il prend comme entrée (a, b, c, …): IEnumerable et f: T1 → T2 et produit (f (a), f (b), f (c) , …): IEnumerable

  • Où: (IEnumerable , Func ) → IEnumerable ; celui-ci prend un IEnumerable contenant des éléments de type T1 et un prédicat sur T1 (c’est-à-dire une fonction qui produit un résultat booléen pour une entrée de type T1). Vous voyez que la sortie est également un IEnumerable contenant des éléments de type T1.

    Cette fois, on pourrait deviner qu’un élément de l’entrée IEnumerable sera présent sur la sortie IEnumerable en fonction du résultat de l’application du prédicat à l’élément. En ajoutant à cela la sémantique du nom de l’opérateur, vous pouvez être sûr qu’il produira la sortie IEnumerable en ne prenant à partir de l’entrée que les éléments qui ont la valeur true lors de l’application du prédicat.

Les personnes ayant une expérience en functional programming pensent généralement comme ceci. Cela vous permet de déduire (ou du moins de deviner …) ce qu’un opérateur ne fait qu’en regardant son type!

En guise d’exercice, essayez de regarder les autres opérateurs introduits par LINQ sur IEnumerables et en déduire leur comportement avant de regarder la documentation!

Ils sont distincts:

Select est tout au sujet de la transformation .

Where est tout au sujet du filtrage .

Sélectionnez mappe un énumérable à une nouvelle structure. Si vous effectuez une sélection sur un IEnumerable, vous obtiendrez un tableau avec le même nombre d’éléments, mais un type différent en fonction du mappage que vous avez spécifié. Where filtre le IEnumerable afin qu’il vous donne un sous-ensemble du IEnumerable d’origine.

Si vous savez comment ils ont implémenté Où et sélectionnez des méthodes d’extension, vous pouvez prédire ce qu’il est en train de faire … J’ai essayé d’implémenter où et de choisir des méthodes d’extension … Vous pouvez y jeter un coup d’œil …

Où la mise en œuvre ::

 public static IEnumerable Where ( this IEnumerable a , Func Method ) { foreach ( var data in a ) { //If the lambda Expression(delegate) returns "true" Then return the Data. (use 'yield' for deferred return) if ( Method.Invoke ( data ) ) { yield return data; } } } 

Sélectionnez la mise en œuvre ::

 public static IEnumerable Select ( this IEnumerable a , Func Method ) { foreach ( var item in a ) { //Each iteration call the delegate and return the Data back.(use 'yield' for deferred return) yield return Method.Invoke ( item ); } } 

Mon implémentation fonctionne bien pour toute collection … Mais elle diffère des méthodes d’extension implémentées par Microsoft, car elles utilisent des arborescences d’expression pour les implémenter.