Entity framework 4.1 code first performance opinions

I am using Entity Framework 4.1 code first with no stored procedures. And I would like to know a general opinion on the performance of this on huge applications seeing that it generates the SQL in the background. Doesn't this go against best practices of not using stored procedures? How do you fine tune these generated code?

I know you can hack into it to use stored procedures, but is there definately going to be support for stored procedures and the other func开发者_运维问答tions you get with going with the database first option?

Does EF 4.1 have any improvements on the database first option? How would I know if I have the latest version of EF?

The generated SQL is reasonably efficient, but although I've not resorted to SP's as yet, I have written some views (in 4.0) and written LINQ against those in places in order to overcome some performance issues.

Does 4.1 go against best practices of stored procedures ? Well there SP's are best practice for a number of reasons - performance is one, isolation and abstraction of the underlying table structure from your code is another. The performance part of this seems to have been abandoned as "probably not that important these days" for reasons that don't smell 100% to me. And the abstraction issue - well you are using EF Code First for a reason - that reason is that you are looking for a persistence framework for your applications objects: by the very act of choosing EF Code First, you are declaring that you don't want to know how they are stored, in what structures, and what happens to get them back.

How do you tune it ? Mainly by being very careful about lazy loading, by monitoring what's going on at the SQL end (EFProf is one tool, MSSql query profiling works too) and generally by fiddling with things.

To ensure you are running the latest EF (if you have been running the CodeFirst CTP) use the NuGet console and

uninstall-package EFCodeFirst
install-package EntityFramework

4.1 has improvements over 4.0 for database first - namely the lightweight dbContext

EDIT: Adding code as requested... Simple case

 foreach (var order in orders) y=order.orderlines.tolist();

which you fix with

foreach (var order in orders.Include("orderlines").tolist()) y=order.orderlines.tolist();

but less obvious is

foreach (var order in orders.Include("orderlines").tolist()) dothing(order);

where

public void dothing(Orderline ol)
{
    if (ol.order.property=true)
    ....
}

to fix this I think you need

foreach (var order in orders.Include("orderlines.orders").tolist()) dothing(order);

(or better still refactor dothing(Orderline ol) to dothing(Orderline ol, Order ord). My point is that with a local database its incredibly easy to miss these. Its only when you profile the sql, or connect to an SQL database on a slow network (think Azure) or just get serious load, that this begins to hurt!