Question

I wonder how LINQ to Objects determines the best way to query in a collection ?

I mean, is there any difference (in how LINQ works internally) between the following LINQ queries:

var lst1 = ListOfComplexClass.Where(p => p.StrValue == "Whatever")
                             .Select(p => p.StrValue);

And

var lst2 = ListOfComplexClass.Select(p => p.StrValue)
                             .Where(p => p == "Whatever");

For example, will the first one filter the collection of ListOfComplexClass and then get the StrValue property?
Or will it do some tuning and execute the Select first and then filter the returned collection?

Answer 1

For example.. will the first one filter the collection of ListOfComplexClass and then get the StrValue property? Or it’ll make some maybe tunning and execute the Select first and then filter the returned collection?

(I am assuming that you meant p => p.StrValue in the Select in the first one.)

Actually, it’s more subtle than that.

Let us say that you take an enumerator on the first one.

var lst1 = ListOfComplexClass.Where(p => p.StrValue == "Whatever")
                             .Select(p => p.StrValue);
var e = lst1.GetEnumerator();

When you call e.MoveNext(), what will happen is that Select will call MoveNext() on an iterator of ListOfComplexClass.Where(p => p.StrValue == "Whatever") which will call MoveNext() an iterator of ListOfComplexClass until it finds an element p with p.StrValue == "Whatever". Then, the projected result of this p will be returned as e.Current.

Now let us consider the second one. Let us say that you take an enumerator of it.

var lst2 = ListOfComplexClass.Select(p => p.StrValue)
                             .Where(p => p == "Whatever");
var e = lst2.GetEnumerator();

When you call e.MoveNext(), Where will call MoveNext() on an iterator of ListOfComplexClass.Select(p => p.StrValue) until it finds an element p with p == "Whatever". Of course, calling MoveNext() on an iterator of ListOfComplexClass.Select(p => p.StrValue) will call MoveNext() on an iterator of ListOfComplexClass and return the projection of Current for that iterator.

Jon Skeet has a good analogy which I’ll steal here. Imagine a deck of cards in random order. Imagine the queries

var suits = deck.Where(c => c.Suit == Suit.Diamond || c.Suit == Suit.Heart)
                .Select(c => c.Suit)

and

var suits = deck.Select(c => c.Suit)
                .Where(c => c == Suit.Diamond || c == Suit.Heart);

Now imagine consuming the result of the first query. It goes like this.

Select asks Where for a card.

Where asks deck for a card.

*Where checks the suit of the card.

If the suit of the card is a diamond or a heart, it returns the card to the Select and Select projects the card to its suit and returns it.

If the suit of the card is not a diamond or a heart, Where asks for another card from deck and loops back to *.

The second query goes like this.

Where asks Select for a suit.

Select asks deck for a card.

deck returns a card to Select.

Select projects the card to its suit.

*Where checks the suit from the Select.

If the suit is a diamond or a heart, Where returns the suit.

If the suit is not a diamond or a heart, Where asks Select for another suit and loops back to *.