使用 Select 代替 Include

Question

so I have this big table that I want to query and it's so slow, I got a tip that using select is more efficient than include. so how can I convert include to select, in this big query.

    ProductEntity? i = await _context.Set<ProductEntity>()
        .Include(i => i.Media)
        .Include(i => i.Categories)
        .Include(i => i.Locations)
        .Include(i => i.Reports)
        .Include(i => i.Comments)!.ThenInclude(x => x.LikeComments)
        .Include(i => i.Bookmarks)
        .Include(i => i.Votes)
        .Include(i => i.User)!.ThenInclude(x => x.Media)
        .Include(i => i.User)!.ThenInclude(x => x.Categories)
        .Include(i => i.Forms)!.ThenInclude(x => x.FormField)
        .Include(i => i.Teams)!.ThenInclude(x => x.User)!.ThenInclude(x => x.Media)
        .Include(i => i.VoteFields)!.ThenInclude(x => x.Votes)
        .AsNoTracking()
        .FirstOrDefaultAsync(i => i.Id == id && i.DeletedAt == null);
    return new GenericResponse<ProductEntity>(_mapper.Map<ProductEntity>(i));

and this is getById method, which just takes one row, I have a getAll that returns a list of products just like this.

Answer 1

The most performant code is always the code that does the least amount of work.

It's possible that what was meant by the 'tip' that "using select is more efficient" may have more to do with answering the question: "do you really, really, really need all that data to be returned?".

Consider, for every .Include you have, EF will be making it's own query to the database to return whatever records are linked by the foreign keys. It's actually pretty efficient on doing that either on the DB side, or in memory if it already has the connected records in memory. (depending on your caching configuration) However, it's going to return the entire Entity referenced. Which may be fine. But, what if each of those 11 sub-entities plus the 7 sub-sub-entities that you have connecting there are each rather large. Do you really, really, really need to return all of that data? Or could you return smaller objects using something like:

var mySmallerObject = await _context.Set<ProductEntity>()
    .Include(i => i.Media)
    .Include(i => i.Categories)
    . . .
    .Select(_ => new SomeMuchSmallerObject {
        SomeFieldOnProduct = _.SomeFieldOnProduct, 
        TheOnlyThingINeedFromMedia = _.Media.TheOnlyThingINeedFromMedia,
        TheOnlyCategoryFieldINeed = _.Categories.TheOnlyCategoryFieldINeed,
        . . . // etc
    })

Note: You would still need all those Includes. However, EF will translate this request into a much more optimized query to the DB that only selects the few fields you actually need, and not even return any of the unwanted fields from the database. This also allows you to take full advantage of any indexes you have on the underlying tables in the DB.

Just a thought.