Comments on: Entity Framework 4 – Using Eager Loading

By: Talking about Entity Framework 4 – Using Eager Loading « Roger Alsing Weblog « EdenSoft Space

Mon, 27 Sep 2010 21:17:15 +0000

[...] Quote Entity Framework 4 – Using Eager Loading « Roger Alsing Weblog [...]

By: M.W.

M.W. — Fri, 08 Jan 2010 14:16:22 +0000

I created an extension method to traverse multiple paths – going from a multiple – to – one set does need something else but this method allows you to pass in multiple properties in a lambda expression:

http://howdoinetmw.blogspot.com/2009/12/how-do-i-create-type-safe-includes-with.html

By: Roger Alsing

Roger Alsing — Fri, 21 Aug 2009 08:51:38 +0000

@Marco, sounds interesting, got any public samples of that?

Do you simply do something like:

public static readonly string SomePath = GetPath(o => o.Details);

or how is it done?

By: bdgbd

bdgbd — Mon, 17 Aug 2009 14:39:06 +0000

Why is this in the context of EF4? Current version of EF already has .Include()

By: Marco

Marco — Sat, 15 Aug 2009 21:36:09 +0000

For what it’s worth, I have been using a hybrid: static readonly strings that get their value from a lambda turned into a string. Good performance (only have the reflection overhead once), I keep programmers from ‘putting crap in there left and right’ and the actual path (lambda or string) only has to be maintained in one spot: if it changes, only one spot to fix it. Kind of comes down to “do whatever works for you”.

By: Stijn

Stijn — Wed, 15 Jul 2009 22:34:05 +0000

Definitely true, but there is a guarantee -if used correctly- that future changes to your edm will always keep your queries working. String based includes will never guarantee you on that one.

By: Roger Alsing

Roger Alsing — Wed, 15 Jul 2009 21:57:31 +0000

The problem with the above solution is that it is only type safe, but not “intention” safe.

There is no compiletime checks for what you pass into a lambda expression.

eg.
I could just as well do:

.Inclue(p => “yeehaa”)
.Include(p => p.Supplicers.Sum().ToString())

etc.

There is _nothing_ that prevents the developer to put crap inside those statements.
The only thing it guarantees at compile time is that is a valid expression.

By: Stijn

Stijn — Tue, 14 Jul 2009 18:10:22 +0000

There is already a good way for using lambda’s for eager loading on collections without losing readability:

1. var query = from p
2. in context.ProductSet
3. .Include(p => p.PriceHistory)
4. .Include(p => p.Suppliers.First().Address)
5. where p.SalePrice > 1000
6. select p;

http://www.codetuning.net/blog/post/Entity-Framework-compile-safe-Includes.aspx

The only difference is you have to use First() on collections, if your coverage is not 100%, which is most often the case in most projects, I would definitely recommend lambda’s over strings. The downside is that it uses reflection, if you care about “micromilliseconds” you should not use this.

But nonetheless, if people prefer strings this is a very maintainable method.

By: Fred Morrison

Fred Morrison — Tue, 26 May 2009 16:18:15 +0000

100% agree with the danger of implict lazy load.

By: Roger Alsing

Roger Alsing — Tue, 26 May 2009 15:51:19 +0000

>>Betting that not all leaves of every node in a tree
>>structure that appears on a web page will be visited by the user

You can easily deal with this by only eager loading the nodes that you _know_ that you want to touch and leave all other paths unloaded.

I also think that “explicit” lazy load is OK.
Atleast the developer is aware that something is going on there.

“Implicit” Lazy Load is dangerous because it hides explicit behavior which can lead to data consistency problems and severe performance issues.

I say “can” because if you know enough about LL, then it is not much of a problem.
But many many developers are far to unaware about the inner workings of O/R mappers, and thus doesn’t know how to deal with LL.

I’ve seen systems where a single web page issues aprox 1000 DB requests just because the developers didn’t know how to reason about LL.

So what I’m saying is that it is not so much LL itself that is the problem , but the lack of knowledge around the topic in general.