使用EF，多次选择或使用包含时哪个更好？

Question

I have two entities, one is box and the other is tennis . There is a foreign key BoxID in table tennis , that is to say, a tennis must be in a box , and the box is a collection of tennis .

Now that I know a tennis ID , I need to check the name of the box to which this tennis belongs. I have two options.

Option A: First find the attribute of this tennis in the tennis table, get the BoxID , and then go to the box table to find the attribute of the box .

var tennisId = 12345;

// Option A:
var tennis = await dbContext.TennisTable
        .SingleOrDefaultAsync(t => t.Id == tennisId);

var box = await dbContext.BoxTable
        .SingleOrDefaultAsync(t => t.Id == tennis.BoxID);

return box.Name;

Option B: Directly use the Include syntax of EF Core to find the tennis and the box to which it belongs, to get the properties of the box .

// Option B:

var tennis = await dbContext.TennisTable
        .Include(t => t.Box);
        .SingleOrDefaultAsync(t => t.Id == tennisId);

return tennis.Box.Name;

In the large-scale practice, which of the above two methods has more performance advantages?

large-scale means that the questions may be much more complicated in real use cases. The count of box and tennis may be billions.

Answer 1

Neither. You don't need an Include statement here.

The Include statement should be used when you want to retrieve additional related entities . But that is not what you want:

I need to check the name of the box to which this tennis belongs.

You only need the Box object to read its name. You don't need to load any additional entities.

var boxName = db.TennisTable
                .Where(t => t.Id == tennisId)
                .Select(t => t.Box.Name)
                .Single();

If you need to account for the tennis object possibly not existing without throwing an exception, use SingleOrDefault() instead of Single() .

In other words:

• Find all tennis objects with this ID . We know there is only one, but by using Where instead of Single , EF does not yet query the database and it can keep using an IQueryable instead.
• For all found entries, select the name of its box . Again, we know there's one entry, but EF will still not instantiate the query because you're not enumerating the IQueryable yet.
• Take the first result . We know it's the only result, but now EF will hit the database with a single (combined) call instead of two separate ones.

If you had used Include logic, you would've retrieved the entire tennis and box objects. My answer only retrieves the box name, which is a significant reduction of data transfer size between the database and your application.

If you had used two calls, you would've loaded both the tennis and box object and you would've had to do two calls, which means increased data transfer size and lowered performance due to additional network calls.