LINQ: Dot Notation vs Query Expression

The "dot" notation is usually called Lambda syntax. The first notation goes by a number of names but I usually call it the query syntax.

I work on a team of 10 developers and we argue at length about which we should use as a standard. In general, the more seasoned (with LINQ) developers migrate towards the Lambda syntax but there are significant exceptions.

Lambda is more concise but performing multiple table joins is a nightmare. Joins are just much cleaner with the query syntax. The flip side is that there are a number of LINQ operations that only exist within the Lambda syntax: Single(), First(), Count() etc.

So, use what you feel most comfortable with and realize that as you gain experience, your preference will likely change. There is great value in being able to read both and there will certainly be situations where you have to use a little bit of both. Other situations will lend themselve to one style over the other. In the end, it all gets translated into the same executable code.

I use whichever syntax is more readable for my query, on a case-by-case basis.

Where possible, I try to avoid mixing and matching the two, although sometimes it's okay (if it's a single call to First() at the end of a query, for example). Deferred execution means it's just as efficient to use a query expression and assign the result to a variable, and then use dot notation using that variable:

var query = from x in y
            orderby z
            group x by x.Name into groups
            // etc
            select foo;

var page = query.Skip(50).Take(10);

As others have said, query expressions are just translated into "normal" C# 3 without query expressions, so there's no penalty for doing this.

Well, the 'dot' notation can be much shorter. Take:

var result = from p in dc.Products
             where p.Id > 5
             select p;

or:

var result = dc.Products.Where(p => p.Id > 5);

I prefer the latter since it is much shorter, and more readable.