Stack OverflowWhat's the hardest or most misunderstood aspect of LINQ?
[+282] [42] Jon Skeet
[2008-10-18 20:47:40]
[ c# linq c#-3.0 ]
[ ]

Background: Over the next month, I'll be giving three talks about or at least including LINQ in the context of C#. I'd like to know which topics are worth giving a fair amount of attention to, based on what people may find hard to understand, or what they may have a mistaken impression of. I won't be specifically talking about LINQ to SQL or the Entity Framework except as examples of how queries can be executed remotely using expression trees (and usually IQueryable).

So, what have you found hard about LINQ? What have you seen in terms of misunderstandings? Examples might be any of the following, but please don't limit yourself!

(3) I would be interested to know when you are going to do these talks, and if there is any way to view them online - Mark Heath
(2) First talk: Copenhagen, October 30th. Hopefully this will be taped. (Whole day!) Second talk: London, Nov 19th in the evening, London .NET Users Group, probably on Push LINQ. Third talk: Reading, Nov 22nd, Developer Developer Day, Implementing LINQ to Objects in 60 minutes. - Jon Skeet
cool, I might see if I can get along to the DDD day in Reading - Mark Heath
(1) Downvoters: please add an explanatory comment. - Jon Skeet
(2) @Jon, Sorry, but I need to close this. - user50049
(3) @Tim: Fair enough - it wasn't getting any more answers anyway. Personally I think it did end up being constructive, mind you - I certainly found it useful to see what people find tricky. I probably wouldn't have asked it now though... - Jon Skeet
@Jon - I can change it to 'too localized' if you like. I have an enumerated list to pick from, I picked the one that I thought fit the best. I'm sure this question will have value for others, it's just not on topic for the Stack Overflow that emerged almost three years after you asked this. - user50049
@Tim: Exactly. Possibly worth migrating to Programmers instead? It's about programmers as people... but also about a specific technology, which makes it a tricky one. I'm really not that picky though, to be honest. - Jon Skeet
@Jon This has quite a few answers (one accepted), it's nearly three years old and migrating it to another site would not be very constructive. I'm not quite sure how the system could be improved based on this experience. Or rather, I can't articulate any kind of suggested improvement. - user50049
@Tim: Maybe one to ask for opinions on in meta? Or straight to Jeff? I don't know how common it is. - Jon Skeet
@Jon these are corner cases that really should be addressed, I suggest meta. Remember, Jeff hates email. Touching a question like this induces a sense of trepidation for all of us [moderators], so a consensus would be extremely useful. - user50049
[+271] [2008-10-18 21:06:20] JaredPar [ACCEPTED]

Delayed execution

(12) Righto - this is clearly the favourite amongst readers, which is the most important thing for this question. I'll add "buffering vs streaming" into the mix as well, as that's closely related - and often isn't discussed in as much detail as I'd like to see in books. - Jon Skeet
(10) Really? I had it's lazy-loaded nature pointed out to me so many times while learning Linq, it was never an issue for me. - Adam Lassek
@ALassek, it really depends on where you learn LINQ from. I've presented for user groups where not a one knew than it was lazy evaluated. - JaredPar
(26) Agree with ALassek. The MSDN documentation clearly states the lazy evaluation nature of LINQ. Maybe the real problem is the lazy programming nature of the developers... =) - Seiti
(4) ... especially when you realize that it applies to LINQ to objects and not just LINQ 2 SQL - when you see 10 web method calls to retrieve a list of items when you're already enumerating through that same list of items and you thought the list was already evaluated - Simon_Weaver
(1) This should be deferred execution, right? Anders has mentioned this many times in his videos about LINQ in MSDN's Channel 9. - Eriawan Kusumawardhono
@eriawan, delayed or deferred works :) - JaredPar
(5) Knowing what the yield statement is and how it works is IMHO critical for a thorough understanding of LINQ. - peSHIr
i have colleagues that, even being told a million times or after reading book in abd book out still don't get the lazy execution behavior of LINQ. - Pauli Østerø
It seems to be a common misconception that IEnumerable is a lazy list, i.e. only evaluated once.. - Robert Jeppesen
[+125] [2009-05-27 18:19:54] dso

I know the deferred execution concept should be beaten into me by now, but this example really helped me get a practical grasp of it:

static void Linq_Deferred_Execution_Demo()
    List<String> items = new List<string> { "Bob", "Alice", "Trent" };

    var results = from s in items select s;

    Console.WriteLine("Before add:");
    foreach (var result in results)


    //  Enumerating the results again will return the new item, even
    //  though we did not re-assign the Linq expression to it!

    Console.WriteLine("\nAfter add:");
    foreach (var result in results)

The above code returns the following:

Before add:

After add:

(2)… <-- I think this is the best blog to explain it in my opinion. (far out 2007, can't believe it's been around that long already) - Phill
[+104] [2008-10-18 21:12:17] smaclell

That there is more than just LINQ to SQL and the features are more than just a SQL parser embedded in the language.

(6) I'm sick of everyone thinking that :/ - TraumaPony
(40) Not everyone does! I still don't know what LINQ to SQL is, and I use LINQ all the damn time. - Robert Rossney
(2) I get so annoyed when I try and explain something using LINQ and the other person just looks at me and says "ohhh I don't use LINQ for anything like that, only SQL" :( - Nathan W
(13) Agreed, many people don't seem to understand that LINQ is a general purpose tool. - Matthew Olenik
[+86] [2009-05-27 21:07:50] erikkallen

Big O notation [1]. LINQ makes it incredibly easy to write O(n^4) algorithms without realizing it, if you don't know what you're doing.


(16) How about an example? - hughdbrown
(4) As far as an example, maybe he means the fact that it is very easy to have a Select clause contain many Sum() operators with each of them causing another pass over the entire recordset. - Rob Packwood
(1) In fact it might even be worth going through what big O notation is and why it's important, as well as some examples of inefficient resulting queries. I think that's what the original poster was suggesting, but I thought I'd mention it anyways. -- EDIT: just realised that this post was 1.5 years old :-) - zcrar70
(7) That wouldn't be O(n^x), that'd be O(xn), which is just O(n). - Malfist
(3) Trying to do a join without the join operator will result in O(n^x): from i1 in range1 from i2 in range2 from i3 in range3 from i4 in range4 where i1 == i2 && i3 == i4 select new { i1, i2, i3, i4}. And I've actually seen this written before. It works, but very slowly. - MarkPflug
[+55] [2008-10-18 21:18:20] Tim Jarvis

I think the fact that a Lambda expression can resolve to both an expression tree and an anonymous delegate, so you can pass the same declarative lambda expression to both IEnumerable<T> extension methods and IQueryable<T> extension methods.

(2) Agreed. I'm a veteran and I just realized this implicit casting was taking place as I started writing my own QueryProvider - TheSoftwareJedi
[+53] [2009-12-16 21:21:58] Simon_Weaver

Took me way too long to realize that many LINQ extension methods such as Single(), SingleOrDefault() etc have overloads that take lambdas.

You can do :

Single(x => == id)

and don't need to say this - which some bad tutorial got me in the habit of doing

Where(x => == id).Single()

+1, very nice. I'll keep it in mind. - Pretzel
(4) I keep forgetting this as well. It's also true of Count(), among others. Do you know if there's any performance difference, in addition to the obvious bonus of code readability? - Justin Morgan
(1) At university, my lecturer wanted to take off points for using these overloads!! I've proven him wrong! - TDaver
(12) It may sound strange but I prefer the second syntax. I find it more readable. - Konamiman
[+40] [2008-10-19 00:05:38] Aaron Powell

In LINQ to SQL I constantly see people not understanding the DataContext, how it can be used and how it should be used. Too many people don't see the DataContext for what it is, a Unit of Work object, not a persistant object.

I've seen plenty of times where people are trying to singleton a DataContext/ session it/ etc rather than making a new time for each operation.

And then there's disposing of the DataContext before the IQueryable has been evaluated but that's more of a prople with people not understanding IQueryable than the DataContext.

The other concept I see a lot of confusion with is Query Syntax vs Expression Syntax. I will use which ever is the easiest at that point, often sticking with Expression Syntax. A lot of people still don't realise that they will produce the same thing in the end, Query is compiled into Expression after all.

(2) Warning: Unit of work can be a small program with the data context as a singleton. - graffic
(15) You should not use the DataContext in a singleton, it's not thread safe. - Aaron Powell
(3) @Slace, not all programs are multitheaded, so it is OK to have the DataContext as a singleton in a lot of "desktop" software - Ian Ringrose
(2) I got bitten by this (using DataContext as a singleton) when I did my first LINQ to SQL project. I don't think that the documentation and books make this obvious enough. Actually, I think the name could be improved, but I'm not sure how. - Roger Lipscombe
(1) It took reading ScottGu's artivles on Linq multiple times to get this pounded in my head. - Evan Plaice
[+34] [2009-04-16 21:09:44] Chris

I think the misunderstood part of LINQ is that it is a language extension, not a database extension or construct.

LINQ is so much more than LINQ to SQL.

Now that most of us have used LINQ on collections, we will NEVER go back!

LINQ is the single most significant feature to .NET since Generics in 2.0, and Anonymous Types in 3.0.

And now that we have Lambda's, I can't wait for parallel programming!

I'd even call it more significant than anonymous types, and possibly even more than generics. - Justin Morgan
[+26] [2008-10-19 05:52:46] Robert Rossney

I for one would sure like to know if I need to know what expression trees are, and why.

(6) I think it's worth knowing what expression trees are and why they exist, but not the details of how to build them yourself. (They're a pain to build by hand, but the compiler will do a great job when converting a lambda expression.) - Jon Skeet
(3) Actually, I was thinking about doing a few blog entries on expression trees (since I do "get" them). I find manipulating expression trees very useful... - Marc Gravell
However, I don't think they be helpful for Jon's talk(s) ;-p - Marc Gravell
I'll need to mention them briefly, but your blog entries would certainly be welcome :) - Jon Skeet
(3) I just worry that expression trees are going to be like the yield statement: something that turned out to be incredibly valuable despite the fact that I didn't understand what it was for at first. - Robert Rossney
(1) Marc Gravell I'd love to read your blog entries on the subject. Looking forward to it - Alexandre Brisebois
I have added a post to this chain with a link... - Marc Gravell
[+20] [2008-10-19 17:47:44] Mark Heath

I'm fairly new to LINQ. Here's the things I stumbled over in my first attempt

  • Combining several queries into one
  • Effectively debugging LINQ queries in Visual Studio.

(21) Debugging LINQ is a topic all by itself, and an important one. I think the greatest weakness of LINQ is that it lets you write blocks of arbitrarily complex logic that you can't step through. - Robert Rossney
(3) these may be a good place to use LINQ pad - Maslow
(2) Agree heartily; that's why I wrote LINQ Secrets Revealed: Chaining and Debugging, just published on, that you may find of assistance. - Michael Sorens
Yes, LinqPad is a great secondary tool for developing your LINQ queries in. Especially when starting out and you're new to the conventions/patterns. - Buffalo
[+20] [2008-12-09 06:46:18] Aaron Powell

Something that I didn't originally realise was that the LINQ syntax doesn't require IEnumerable<T> or IQueryable<T> to work, LINQ is just about pattern matching.

alt text [1]

Here is the answer [2] (no, I didn't write that blog, Bart De Smet did, and he's one of the best bloggers on LINQ I've found).


(1) You might find this blog post interesting too:… - Jon Skeet
Nice post Jon (I do subscribe to your blog, only recently though). - Aaron Powell
[+19] [2008-10-18 23:26:22] James Curran

I still have trouble with the "let" command (which I've never found a use for) and SelectMany (which I've used, but I'm not sure I've done it right)

(2) Any time you want to introduce a variable you would use a let statement. Think of a traditional loop where you are introducing variables within it and giving each variable a name to help the readability of code. Sometimes it is also nice where you have a let statement evaluating a function result, which you can then select and order by on without having to evaluate the result twice. - Rob Packwood
'let' allows you to do composite types. Handy stuff. - Phill
[+19] [2008-10-19 00:53:25] denis phillips

Understanding when the abstraction among Linq providers leaks. Some things work on objects but not SQL (e.g., .TakeWhile). Some methods can get translated into SQL (ToUpper) while others can't. Some techniques are more efficient in objects where others are more effective in SQL (different join methods).

(1) This is a very good point. It doesn't help that Intellisense will show you ALL of them and it will usually even compile. Then you blow up at runtime. I hope VS 2010 does a better job of showing relevant extension methods. - Jason Short
[+12] [2008-10-22 06:23:15] Krishna Kumar

Couple of things.

  1. People thinking of Linq as Linq to SQL.
  2. Some people think that they can start replacing all foreach/logic with Linq queries without considering this performance implications.

[+11] [2008-10-20 09:08:48] Marc Gravell

OK, due to demand, I've written up some of the Expression stuff. I'm not 100% happy with how blogger and LiveWriter have conspired to format it, but it'll do for now...

Anyway, here goes... I'd love any feedback, especially if there are areas where people want more information.

Here it is [1], like it or hate it...


[+10] [2009-06-04 12:12:37] Per Erik Stendahl

Some of the error messages, especially from LINQ to SQL can be pretty confusing. grin

I've been bitten by the deferred execution a couple of times like everyone else. I think the most confusing thing for me has been the SQL Server Query Provider and what you can and can't do with it.

I'm still amazed by the fact you can't do a Sum() on a decimal/money column that's sometimes empty. Using DefaultIfEmpty() just won't work. :(

(1) Shold be prette easy to slap a Where on that query to make sum work - Esben Skov Pedersen
[+9] [2009-01-30 15:16:27] Steve

I think a great thing to cover in LINQ is how you can get yourself in trouble performance-wise. For instance, using LINQ's count as a loop condition is really, really not smart.

[+7] [2010-09-28 20:21:06] Valera Kolupaev

That IQueryable accept both, Expression<Func<T1, T2, T3, ...>> and Func<T1, T2, T3, ...>, without giving a hint about performance degradation in 2nd case.

Here is code example, that demonstrates what I mean:

public void QueryComplexityTest()
    var users = _dataContext.Users;

    Func<User, bool>                funcSelector =       q => q.UserName.StartsWith("Test");
    Expression<Func<User, bool>>    expressionSelector = q => q.UserName.StartsWith("Test");

    // Returns IEnumerable, and do filtering of data on client-side
    IQueryable<User> func = users.Where(funcSelector).AsQueryable();
    // Returns IQuerible and do filtering of data on server side
    // SELECT ... FROM [dbo].[User] AS [t0] WHERE [t0].[user_name] LIKE @p0
    IQueryable<User> exp = users.Where(expressionSelector);

Can you explain? I'm not following... - Pretzel
@Pretzel I have added code example, that demonstrate my issue. - Valera Kolupaev
[+6] [2009-01-15 14:10:46] Martin

I don't know if it qualifies as misunderstood - but for me, simply unknown.

I was pleased to learn about DataLoadOptions and how I can control which tables are joined when I make a particular query.

See here for more info: MSDN: DataLoadOptions [1]


[+6] [2009-02-16 01:30:36] Jack Ukleja

I would say the most misunderstood (or should that be non-understood?) aspect of LINQ is IQueryable and custom LINQ providers.

I have been using LINQ for a while now and am completely comfortable in the IEnumerable world, and can solve most problems with LINQ.

But when I started to look at and read about IQueryable, and Expressions and custom linq providers it made my head spin. Take a look at how LINQ to SQL works if you want to see some pretty complex logic.

I look forward to understanding that aspect of LINQ...

[+6] [2009-04-08 12:36:58] HashName

As most people said, i think the most misunderstood part is assuming LINQ is a just a replacement for T-SQL. My manager who considers himself as a TSQL guru would not let us use LINQ in our project and even hates MS for releasing such a thing!!!

Too many people use it as a replacement for TSQL. Most of them have never heard of an execution plan. - erikkallen
+1 because I agree with your manager, at least insofar as allowing LINQ to SQL in any project. LINQ to Objects is another matter entirely. - NotMe
[+5] [2008-10-28 11:15:18] user31939

What does var represent when a query is executed?

Is it iQueryable, iSingleResult, iMultipleResult, or does it change based on the the implementation. There's some speculation about using (what appears to be) dynamic-typing vs the standard static-typing in C#.

AFAIK var always is the concrete class in question (even if it's an anonymous type) so it's never IQueryable, ISingleResult or anything beginning with 'I' (concrete classes that begin with 'I' need not apply). - Motti
[+5] [2010-03-04 22:29:13] Rob Packwood

How easy it is to nest a loop is something I don't think everyone understands.

For example:

from outerloopitem in outerloopitems
from innerloopitem in outerloopitem.childitems
select outerloopitem, innerloopitem

+1, whoa. that's pretty powerful. - Pretzel
[+4] [2008-11-26 16:38:32] Richard Ev

group by still makes my head spin.

Any confusion about deferred execution [1] should be able to be resolved by stepping through some simple LINQ-based code and playing around in the watch window.


(1) I've found that implementing quite a bit of LINQ to Objects for fun really helps :) But yes, it is a bit confusing - certainly if I haven't done any LINQ for a while I have to go back to the signatures. Likewise "join" vs "join into" often gets me... - Jon Skeet
[+4] [2009-09-15 06:56:07] Alex

Compiled Queries

The fact that you can't chain IQueryable because they are method calls (while still nothing else but SQL translateable!) and that it is almost impossible to work around it is mindboggling and creates a huge violation of DRY. I need my IQueryable's for ad-hoc in which I don't have compiled queries (I only have compiled queries for the heavy scenarios), but in compiled queries I can't use them and instead need to write regular query syntax again. Now I'm doing the same subqueries in 2 places, need to remember to update both if something changes, and so forth. A nightmare.

[+4] [2010-09-30 14:27:53] NotMe

I think the #1 misconception about LINQ to SQL is that you STILL HAVE TO KNOW SQL in order to make effective use of it.

Another misunderstood thing about Linq to Sql is that you still have to lower your database security to the point of absurdity in order to make it work.

A third point is that using Linq to Sql along with Dynamic classes (meaning the class definition is created at runtime) causes a tremendous amount of just-in-time compiling. Which can absolutely kill performance.

(4) It is very beneficial to already know SQL, however. Some SQL that is emitted by Linq to SQL (and other ORM's) can be downright dubious, and knowing SQL helps diagnose such problems. Also, Linq to SQL can make use of stored procedures. - Robert Harvey
[+2] [2008-10-18 21:04:46] Ryan Eastabrook

Lazy Loading.

[+2] [2009-01-07 17:42:27] Ash Machine

As mentioned, lazy loading and deferred execution

How LINQ to Objects and LINQ to XML (IEnumerable) are different from LINQ to SQL(IQueryable)

HOW to build a Data Access Layer, Business Layer, and Presentation Layer with LINQ in all layers....and a good example.

The first two I can do. I wouldn't like to try doing the third yet in a "this is the right way to do it" sense... - Jon Skeet
+1, until you pointed it out, I hadn't realized that LINQ-to-Objects and LINQ-to-XML were IEnumerable as opposed to LINQ-to-SQL as IQueryable, but it makes sense. Thanks! - Pretzel
[+2] [2010-03-31 11:23:15] stackuser1

As most people said, i think the most misunderstood part is assuming LINQ is a just a replacement for T-SQL. My manager who considers himself as a TSQL guru would not let us use LINQ in our project and even hates MS for releasing such a thing!!!

[+2] [2010-09-30 05:37:58] Naeem Sarfraz

Transactions (without using TransactionScope)

[+1] [2008-10-18 22:51:03] user21582

I think you should give more attention to the most commonly used features of LINQ in detail - Lambda expressions and Anonymous types, rather than wasting time on "hard to understand" stuff that is rarely used in real world programs.

(4) I agree with the principle, but in reality almost all of the hard-to-understand bits are used frequently in real world programs - just without people really understanding them. - Jon Skeet
[+1] [2008-10-28 11:09:01] user31939

Which is faster, inline Linq-to-Sql or Linq-to-Sql using Tsql Sprocs

... and are there cases where it's better to use server-side (Sproc) or client-side (inline Linq) queries.

[+1] [2008-11-04 13:43:52] Pop Catalin

Comprehension syntax 'magic'. How does comprehension syntax gets translated into method calls and what method calls are chosen.

How does, for example:

from a in b
from c in d
where a > c
select new { a, c }

gets translated into method calls.

I did a little bit of this in the talk, but mostly just "this is the sort of thing the compiler does" - including "it doesn't know that the translation will call extension methods etc". The details are pretty complicated, of course... - Jon Skeet
(I did include a bit on transparent identifiers though, which is relevant to your example.) - Jon Skeet
I always find it easier to understand if I try to rethink it as a method chain: b.SelectMany(a => d, (a,c) => new { a=a, c=c }).Where(thing => thing.a > thing.c).Select(otherthing => new {a=otherthing.a, c=otherthing.c} ) - JerKimball
[+1] [2008-12-09 06:15:19] Simon_Weaver

For LINQ2SQL : Getting your head around some of the generated SQL and writing LINQ queries that translate to good (fast) SQL. This is part of the larger issue of knowing how to balance the declarative nature of LINQ queries with the realism that they need to execute fast in a known environment (SQL Server).

You can get a completely different SQL generated query by changing a tiny tiny thing in the LINQ code. Can be especially dangerous if you are creating an expression tree based on conditional statements (i.e. adding optional filtering criteria).

[+1] [2008-12-09 20:01:52] Brian Rasmussen

I find it a bit disappointing that the query expression syntax only supports a subset of the LINQ functionality, so you cannot avoid chaining extension methods every now and then. E.g. the Distinct method cannot be called using the query expression syntax. To use the Distinct method you need to call the extension method. On the other hand the query expression syntax is very handy in many cases, so you don't want to skip that either.

A talk on LINQ could include some practical guidelines for when to prefer one syntax over the other and how to mix them.

Personally I'm glad that the query expression syntax doesn't include very many operators. The dot notation is fine when you need to use it, and this balance keeps C# still a reasonably small language. The query expression part of the spec is nice and short - I wouldn't want a really long section. - Jon Skeet
[+1] [2009-03-06 06:57:36] Simon_Weaver

This is of course not 'the most hardest' but just something to add to the list :

ThenBy() extension method

Without looking at its implementation I'm initially puzzled as to how it works. Everyone understands just fine how comma separated sort fields work in SQL - but on face value I'm skeptical that ThenBy is going to do what I really want it to do. How can it 'know' what the previous sort field was - it seems like it ought to.

I'm off to research it now...

(4) The trick is that ThenBy is an extension method on IOrderedEnumerable (or IOrderedQueryable) rather than just IEnumerable/IQueryable. You can download my (very naive!) implementation from my talks page: - see "LINQ to Objects in 60 minutes" - Jon Skeet
[+1] [2010-12-13 23:10:53] Amir Karimi

How LINQ to SQL translate it!

Suppose that we have a table with 3 fields; A, B & C (They are integers and table name is "Table1").
I show it like this:
[A, B, C]

Now we want to get some result such as this:
[X = A, Y = B + C]

And we have such a class:

public class Temp
   public Temp(int x, int y)
      this.X = x;
      this.Y = y;

   public int X { get; private set; }
   public int Y { get; private set; }

Then we use it like this:

using (MyDataContext db = new MyDataContext())
   var result = db.Table1.Select(row => 
                   new Temp(row.A, row.B + row.C)).ToList();

The generated SQL query is:

SELECT [t0].[A] AS [x], [t0].[B] + [t0].[C] AS [y]
FROM [Table1] AS [t0]

It translates the .ctor of the Temp. It knows that I want "row.B + row.C" (even more...) to put on the "y" paramter of my class constructor!

These translations are very intrested to me. I like that and I think writing such translators (LINQ to Something) is a little hard!

Of course! It's a bad news: the LINQ to Entities (4.0) does not support constructors with parameters. (Why not?)

Yeah I really miss this feature in Linq to Entities... - TDaver
[+1] [2010-12-31 13:09:27] iTSrAVIE

I find "Creating an Expression Tree" to be tough. There are many things that bug me w.r.t what you can to with LINQ, LINQ to SQL and ADO.Net altogether.

[+1] [2011-03-07 11:58:46] Patrik Lindström

Explain why Linq does not handle left outer join as simple as in sql syntax. See this articles: Implementing a Left Join with LINQ [1], How to: Perform Left Outer Joins (C# Programming Guide) [2] I got so disappointed when I came across this obstacle that all my respect for the language vanished and I decedid that it was just something that quickly would fade away. No serious person would want to work with a syntax that lacks these battlefield proven primitives. If you could explain why these sort of set operation are not supported. I would become a better and more openminded person.


(1) interesting. I haven't found a need for the Left Outer join in Linq so far. Can you provide situations where this would be the best choice and how it would benifit the execution of the query ? - Alexandre Brisebois
(1) Left outer joins don't make sense in the context of object relational mapping (which is what LINQ does). Objects shouldn't be hydrated with all their fields set to null! - Billy ONeal
But at the time everyone spoke how Linq now totally should replace SQL. Only old stubborn people use sql and stored procedure I was told. I was building a website where the economy dept people where matching (reconsiliating) external invoices with internal accounting. Eg we got an invoice for a subcontracter who worked at project. The subcontracter Name matches, the activitity matches the client mathces but Project code does not matches. Something has to be done. Guess who is the project leader contact them, contact the subcontracter etd. So this is a left join al lot application. - Patrik Lindström
(1) I like your inclusion of left join here, I didn't want to double post. Your dismissal of LINQ otherwise is heavy-handed. I'd like to see left-join as an operator or something too, but I still use LINQ all the time. Beats the hell out of the old way. - Jason Kleban
I am now more openminded and use Linq. I even try to only use Linqpad for day to day adhoc database queries. But now it is group by in Linq that confuses me. (see eg…) Its like now I get it and no i dont. - Patrik Lindström
[+1] [2011-04-27 13:44:50] GibboK

I have found hard to find clear information about Anonymous types specially in regard of performances in web application. Also I would suggest better and practical Lamda expressions examples and "How to" section in quering and performance related topics.

Hope my brief list can help!

[0] [2010-03-31 11:32:13] user305950

The fact that you can't chain IQueryable because they are method calls (while still nothing else but SQL translateable!) and that it is almost impossible to work around it is mindboggling and creates a huge violation of DRY. I need my IQueryable's for ad-hoc in which I don't have compiled queries (I only have compiled queries for the heavy scenarios), but in compiled queries I can't use them and instead need to write regular query syntax again. Now I'm doing the same subqueries in 2 places, need to remember to update both if something changes, and so forth. A nightmare.

[-1] [2009-06-19 02:00:50] RCIX

Something i bet almost on one knows: you can use inline ifs in a linq query. Something like this:

var result = from foo in bars where (
    ((foo.baz != null) ? foo.baz : false) &&
    foo.blah == "this")
    select foo;

I would suppose you can insert lambdas as well although i haven't tried.

(2) That's just a conditional expression - why wouldn't you be able to use that? - Jon Skeet
I was of the (probably mistaken) impression that that is like a regular if: you wouldn't see any imbedding of regular ifs like that now would you? or i could be wrong... - RCIX
(3) If is a statement and the conditional operator is an expression. They are different forms of the same concept of branching. In this case, though, you could do "foo.baz ?? false" and use the null coalescing operator :-) - Bryan Watts
I think more people know the ternary operator than the opposite.. - devoured elysium
Conditional expressions resulting in boolean values can be reduced to boolean or/and expressions, so (foo.baz != null) ? foo.baz : false is equivalent to (foo.baz != null) && foo.baz. I think this can be applied to any ternary expression that could be passed as a where condition. So that's not all that surprising, IMHO - Justin Morgan