LINQ Keywords vs. Methods

Question

I can do:

var something = things.Where(thing => thing.stuff == yup);
var somethingelse = something.Select(thing => thing.otherstuff);

or

var something = from thing in things
                where thing.stuff == yup
                select thing;
var somethingelse = from thing in something
                    select thing.otherstuff;

Obviously if this were real world there's the benefit with the keyword version of doing:

var somethingelse = from thing in something
                    where thing.stuff == yup
                    select thing.otherstuff;

But then of course you could argue that you could do:

var somethingelse = things.Where(thing => thing.stuff == yup)
                          .Select(thing => thing.otherstuff);

Anyway the question itself: what are the pros/cons to using each of these variants? Are they identical but just different syntax code-side? If you combine two method versions (i.e., where/select as above) is it less efficient than using the keyword syntax combining both into one line?

I love LINQ and I don't want to lose any efficiency where some could be gained by using one type or another.

Answer 1

The query syntax will be converted into the method syntax by the compiler in a first pass, and then compiled from that method syntax into IL code in a second pass. There is no difference in the resulting compiled code between code written using the query syntax verses code written directly in method syntax. (Although not all of the methods are represented in query syntax, so some queries cannot be written without partial or complete use of method syntax.)

The only difference is the personal preference of the coder; what you find easier to read or write.

From my personal experiences certain types of queries are easier to read and/or write in one syntax over the other, but that's entirely a matter of opinion and does vary between people. Use whichever you're most comfortable with in any given situation.

Answer 2

According to MSDN some queries must be written in the method syntax, but in general they are identical. Query syntax is converted to method syntax before compilation so they end up generating the same IL. I personally prefer method syntax. I think consistency is important and so I use only method syntax.

via msdn;

"For example, you must use a method call to express a query that retrieves the number of elements that match a specified condition."

Article with all the info you're looking for; http://msdn.microsoft.com/en-us/library/vstudio/bb397947.aspx

Answer 3

Compiler will treat the code in both method and LINQ syntax the same way. Use may depend on your own ability and preference.

This SO thread has some answers on this issue.

This SO answer warns that this all depend on implementation for LINQ.

Answer 4

The LINQ query operators you call out here function as syntactic sugar for the extension methods in the System.Linq namesapce*, and as such, are identical as far as runtime efficiency. You can even create your own query opertors that the compiler will magically translate into methods, if you so choose.

Part 3 of the excellent C# in Depth by Jon Skeet covers LINQ, including this question, in much more detail if you're interested in learning more. See also http://msdn.microsoft.com/en-us/library/vstudio/bb397947.aspx and http://msdn.microsoft.com/en-us/library/vstudio/bb397896.aspx on MSDN.

*You can also provide your own implementations of the extension methods normally exposed in the System.Linq namespace, in the same way you can create custom LINQ operators.

Answer 5

When using the query syntax (using the LINQ keywords), the compiler translates the code into the corresponding LINQ method calls yielding equivalent code. As far as the query is concerned, there is no difference in performance, each should produce the same results. It only affects readability of the query depending on which you are more comfortable with.

The only "problems" (if you see it that way) with the query syntax is that it will translate to a specific set of LINQ methods. If you look at all the LINQ methods available, there are additional overloads available for many of the standard operators as well as other methods not available in the query syntax. You will not be able to use these methods in such a query.

For instance, you cannot use the Distinct() operator on queries using the query syntax (as of now, hopefully in a future version and backported). If you wanted to use it, you must use the method syntax. So you would have to either mix syntaxes (which is a little ugly when queries get more complex IMHO) or use the method calls exclusively.

// get all distinct user names
var query1 =
    (from user in Users
    select user.Name).Distinct();

// vs.
var query2 = Users
    .Select(user => user.Name)
    .Distinct();

If you asked me, use the query syntax whenever possible. Use the method call syntax if absolutely necessary. Mixing styles is a judgement call, just go for whatever is more readable and be consistent.