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

Question

Dans linq, il existe les méthodes Select et Where. Que doivent savoir tous les développeurs sur ces deux méthodes (Exemple: quand utiliser l’une sur l’autre, les avantages sur l’autre, etc.)

Answer 1

Où

trouve les éléments qui correspondent et ne renvoie que ceux qui le font.

-> IEnumerable<A> in, IEnumerable<A> sur

Sélectionner

renvoie quelque chose pour tous les éléments de la source. Ce quelque chose pourrait être les éléments eux-mêmes, mais sont plus généralement une projection d'une certaine sorte.

-> IEnumerable<A> in, IEnumerable<B> sur

Answer 2

Ils sont distincts:

Select concerne la transformation .

Where concerne le filtrage .

Answer 3

Sélectionnez et Où sont deux choses complètement différentes des opérateurs agissant sur IEnumerables.

La première est ce que nous appelons un Opérateur de Projection, alors que la dernière est une Restriction de l'Opérateur.

Un moyen intéressant d'avoir un aperçu sur le comportement de ces opérateurs est de prendre un coup d'oeil à leur "type fonctionnel".

• Sélectionnez : (IEnumerable<T1>, Func<T1,T2>) → IEnumerable<T2>; il prend comme données d'entrée à la fois un IEnumerable contenant des éléments de type T1 et une fonction de transformer les é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 va produire sa sortie en appliquant la fonction d'entrée sur chaque élément de l'entrée IEnumerable, et envelopper les résultats à l'intérieur d'une nouvelle interface IEnumerable.

  À l'aide de certains des mathématiques comme la notation, il prend comme données d'entrée (a, b, c, ...) : IEnumerable<T1> et f : T1 → T2 et produit (f(a), f(b), f(c), ...) : IEnumerable<T2>

• Où : (IEnumerable<T1>, Func<T1, bool>) → IEnumerable<T1> ; celui-ci prend un IEnumerable contenant des éléments de type T1 et d'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 suppose qu'un élément de l'entrée IEnumerable sera présent sur la sortie IEnumerable selon le résultat de l'application de l'attribut de l'élément. En ajoutant à cela la sémantique du nom de l'opérateur, vous pouvez être sûr qu'il va produire la sortie IEnumerable en prenant de l'entrée d'un seul de ces éléments est évaluée à true sur l'application du prédicat.

Les gens avec la programmation fonctionnelle fond généralement de penser comme cela. Il vous permet de déduire (ou au moins le deviner...) qu'un opérateur ne fait seulement en regardant ce genre!

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

Answer 4

Sélectionnez mappe un énumérable sur 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 l'IEnumerable afin qu'il vous donne un sous-ensemble de l'IEnumerable d'origine.

Answer 5

Si vous savez comment ils ont mis en œuvre des Où puis sélectionnez les méthodes d'extension, vous pouvez prédire ce qu'il est en train de faire... J'ai essayé de mettre en œuvre des où puis sélectionnez les méthodes d'extension... Vous pouvez avoir un coup d'oeil...

Lorsque La Mise En Œuvre ::

public static IEnumerable<Tsource> Where<Tsource> ( this IEnumerable<Tsource> a , Func<Tsource , bool> 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 mise en œuvre ::

public static IEnumerable<TResult> Select<TSource , TResult> ( this IEnumerable<TSource> a , Func<TSource , TResult> 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 application fonctionne très bien pour toute la collection... Mais elle diffère de Microsoft a mis en place des méthodes d'Extension, Car ils utilisent des arbres d'expression pour mettre en œuvre le même.