实体框架计数效率

Question

I query the school entity from the database. And then, I try to get the number of students in that school by doing this:

var school = context.schools.Where(s=>s.ID == 1).Single();
int cnt = school.students.Count();

But I see that the query sent to database gets all the student records in that school, and the counting is done on the application server.

Whereas the following just queries the COUNT() from the database, as it should be:

int cnt = context.students.Where(s=>s.schoolID == 1).Count();

Why is there such a difference between these two approaches? Shouldn't the first query also use COUNT() to be efficient?

Note: Not querying the school entity is not an option because I am using some of its fields.

Answer 1

school.students.Count() working via LazyLoading , so at first, you fetch students: school.students and then .Count() them on client side, as you already wrote. But you can modify your code the way, which will perform one trip to database:

var answer = (from sch in context.schools
              where sch.ID == 1
              join st in context.students on sch.ID equals st.schoolID into subs
              from sub in subs.DefaultIfEmpty()
              group sub by new { sch.ID, sch.Name, sch.Location } into gr
              select new 
              {
                  gr.Key.Name,
                  gr.Key.Location,
                  Count = gr.Count(x => x != null)
              }).First();

sch.Name , sch.Location - school's fields, which you need for further use

Answer 2

Queries are run at the last possible moment to make them as efficient as possible - called Lazy Loading - and in your first example your Single() call forces the data provider to be less lazy than you might like.

When you call Single() , you're asking for an entire Student record - the first in the list of all student records, so the query has to run ( GET SchoolId, SchoolName, .... FROM SCHOOLS WHERE SchoolId = 1 ) to get you that data. Then afterwards you call Count() , replaying the query except only selecting COUNT .

Instead in your second example, you call Count() only after a Where() call. Where() doesn't force the query to play because you haven't accessed any data yet, so the data provider can smartly only play a GET COUNT - type query on the database after it evaluates Count() .

How to tell if a LINQ method will 'play' your query? The way I remember is that if it returns IQueryable<T> it will not play your query, anything else, it will.

Answer 3

It's all about the lazy loading, but the effect is two-fold:

1. context.schools.Where(s=>s.ID == 1).Single() will return a school entity without any students loaded (lazy loading part 1). But,
2. school.students.Count() has to hit the database for all students because of the .students part - since they were not loaded in on the first line, they will be all be loaded in (because you implicitly asked for that - lazy loading part 2) then the Count() fires.

To cut down on the calls, either do as you suggested: int cnt = context.students.Where(s=>s.schoolID == 1).Count(); which will result in 2 db calls, or create a grouped result as in the original answer