Linq: What is the difference between Select and Where

Question

The Select and Where methods are available in Linq. What should every developer know about these two methods? For example: when to use one over th

Answer 1

Where

finds items that match and only returns those that do (filtering).

-> IEnumerable<A> in, IEnumerable<A> out

Select

returns something for all items in the source (projection / transformation). That something might be the items themselves, but are more usually a projection of some sort.

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

Answer 2

Where ~= Filter

Select ~= Map

Both returns IEnumerable<T>

Answer 3

Select and Where are two completely different operators acting on IEnumerables.

The first one is what we call a Projection Operator, while the last one is a Restriction Operator.

One interesting way to have insight on the behavior of such operators is to take a look at their "functional type".

• Select : (IEnumerable<T1>, Func<T1,T2>) → IEnumerable<T2>; it takes as input both an IEnumerable containing elements of type T1 and a function transforming elements of type T1 into elements of type T2. The output is an IEnumerable containing elements of type T2.

  From this, one can easily guess that this operator will produce its output by applying the input function on each element of the input IEnumerable, and wrapping the results inside a new IEnumerable.

  Using some math-like notation, it takes as input (a, b, c, ...) : IEnumerable<T1> and f : T1 → T2 and produces (f(a), f(b), f(c), ...) : IEnumerable<T2>

• Where : (IEnumerable<T1>, Func<T1, bool>) → IEnumerable<T1> ; this one takes an IEnumerable containing elements of type T1 and a predicate on T1 (that is, a function that produces a boolean result for an input of type T1). You see that the output is also an IEnumerable containing elements of type T1.

  This time one would guess that an element of the input IEnumerable will be present on the output IEnumerable depending on the result of the application of the predicate to the element. Adding to this the semantics of the operator name, you can be sure that it will produce the output IEnumerable by taking from the input one only those elements that evaluates to true on the application of the predicate.

People with functional programming background usually think like this. It allows you to deduce (or at least guess...) what an operator does only by looking at it's type!

As an exercise, try to look at other operators introduced by LINQ on IEnumerables and deduce their behavior, before looking at the documentation!

Answer 4

Select maps an enumerable to a new structure. If you perform a select on an IEnumerable, you will get an array with the same number of elements, but a different type depending on the mapping you specified. Where filters the IEnumerable so that it gives you a subset of the original IEnumerable.

Answer 5

If you know how they have implemented Where and select extension methods you can predict what it is doing... I tried to implement where and select extension methods... You can have a look at it...

Where Implementation ::

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;
        }
    }
}

Select implementation ::

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 );
    }
}

My implementation works fine for any collection... But it differs from Microsoft implemented Extension methods, Because they use expression trees to implement the same.

Answer 6

They are distinct:

Select is all about transformation.

Where is all about filtering.