Is Select optional in a LINQ statement?

Question

I was looking over some LINQ examples, and was thereby reminded they are supposed to have a "select" clause at the end.

But I have a LINQ that's working and has no "Select":

public IEnumerable<InventoryItem> Get(string ID, int packSize, int CountToFetch)
{
    return inventoryItems
        .Where(i => (i.Id.CompareTo(ID) == 0 && i.PackSize > packSize) || i.Id.CompareTo(ID) > 0)
        .OrderBy(i => i.Id)
        .ThenBy(i => i.PackSize)
        .Take(CountToFetch)
        .ToList();
}

Is this because:

(a) select is not really necessary?
(b) Take() is doing the "select"
(c) ToList() is doing the "select"

Truth be told, this was working before I added the "ToList()" also... so it seems LINQ is quite permissive/lax in what it allows one to get away with.

Also, in the LINQ I'm using, I think the OrderBy and ThenBy are redundant, because the SQL query used to populate inventoryItems already has an ORDER BY ID, PackSize clause. Am I right (that the .OrderBy() and .ThenBy() are unnecessary)?

Answer 1

Linq statements do in fact need a select clause (or other clauses, such as a group by). However, you're not using Linq syntax, you're using the Linq Enumerable extension methods, which all (for the most part) return IEnumerable<T>. Therefore, they do not need the Select operator.

var result = from item in source
             where item.Value > 5
             select item;

Is exactly the same as

var result = source.Where(item => item.Value > 5);

And for completeness:

var result = from item in source
             where item.Value > 5
             select item.Value;

Is exactly the same as

var result = source.Where(item => item.Value > 5)
                   .Select(item => item.Value);

Linq statements (Linq syntax statements) need a special clause at the end to signify what the result of the query should be. Without a select, group by, or other selection clause, the syntax is incomplete, and the compiler does not know how to change the expression into the appropriate extension methods (which is what Linq syntax actually gets compiled to).

As far as ToList goes, that's one of the Enumerable extension methods that does not return an IEnumerable<t>, but instead a List<T>. When you use ToList or ToArray the Enumerable is enumerated immediately and converted to a list or array. This is useful if your query is complex and you need to enumerate the results multiple times without running the query multiple times).