EF渴望加载和延迟加载的区别？

Question

I'm new to EF and have read some articles. After reading I got confused in what is difference between lazy loading and eager loading?

• Can both type of queries be compiled?
• Can both type of queries return IQuerable and IEnumerable ?
• Can both type of queries have Linq to Entities query syntex (select, from, where) and lambda expressions?

Kindly guide and help me.

Thanks a lot for your time and guidance

Answer 1

About the difference between lazy and eager loading:

Suppose you have a Customer object with has a property List<Invoice> Invoices (which is in a different table and joined automatically by the Entity Framework).

With lazy loading the invoices won't be fetched immediately when your Customer object is instantiated, but only when you need it / access it explicitely.

With eager loading your invoices will be fetched and constructed / filled on the object immediately (which introduces some unnecessary performance overhead if you build a huge list of Customers but don't really need all the invoices to be readily available on the object).

You'll find some documentation here .

Answer 2

Can both type of queries be compiled?

Only eager loading can be part of manually pre-compiled query. Lazy loading query is automatically created by EF and it is EF internal behavior if it actually pre-compiles it.

Can both type of queries return IQuerable and IEnumerable?

In eager loading you can control if the query returns IQueryable or IEnumerable . Lazy loading query happens out of your control and you cannot modify it. If you want to use IQueryable for lazily loaded navigation properties you must use third option called explicit loading where you get IQueryable query for given navigation property and you can modify it.

Can both type of queries have Linq to entities queries syntax (select, from, where) and lambda expressions?

No. Neither of these queries have select, from, where. Lazy loading happens out of your control and eager loading doesn't allow filtering - in both cases you always load all related objects.

Example of explicit query (the only type of loading where you can use query):

var query = ((EntityCollection<MyEntity>)parent.Children).CreateSourceQuery()
                                                         .Where(...);

Answer 3

Lazy loading is only loading related objects at the moment this is actually needed, eager loading is the opposite of this. The choice of strategy could have a big impact on performance, eg loading a big dataset when you don't actually need it.