如何在通用仓储（Generic Repository）中使用ThenInclude()实现预加载？

这个场景我太熟悉了——通用仓储的优势是复用，但碰到多级关联预加载的时候，硬编码Include肯定不行，得让仓储支持动态的链式扩展才行。咱们一步步来解决：

核心思路：让通用仓储接受自定义的查询扩展逻辑 #

通用仓储不能提前知道每个实体的关联关系，所以最好的方式是把Include/ThenInclude的配置权交给调用方，通过传入一个处理IQueryable的委托来实现多级预加载，而不是在仓储里写死特定实体的关联。

第一步：改造通用仓储接口和实现 #

先给你的通用仓储添加支持自定义查询扩展的方法，比如：

通用仓储接口

public interface IGenericRepository<TEntity> where TEntity : class
{
    // 提供基础的IQueryable，方便调用方自由扩展
    IQueryable<TEntity> AsQueryable();
    
    // 带预加载配置的查询方法
    Task<List<TEntity>> GetAllAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> configureQuery = null);
    
    // 其他CRUD方法（比如GetByIdAsync也可以同理扩展）
    Task<TEntity?> GetByIdAsync(int id, Func<IQueryable<TEntity>, IQueryable<TEntity>> configureQuery = null);
}

仓储实现类

public class GenericRepository<TEntity> : IGenericRepository<TEntity> where TEntity : class
{
    protected readonly DbContext _dbContext;

    public GenericRepository(DbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public IQueryable<TEntity> AsQueryable()
    {
        return _dbContext.Set<TEntity>().AsQueryable();
    }

    public async Task<List<TEntity>> GetAllAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> configureQuery = null)
    {
        var query = AsQueryable();
        if (configureQuery != null)
        {
            query = configureQuery(query);
        }
        return await query.ToListAsync();
    }

    public async Task<TEntity?> GetByIdAsync(int id, Func<IQueryable<TEntity>, IQueryable<TEntity>> configureQuery = null)
    {
        var query = AsQueryable();
        if (configureQuery != null)
        {
            query = configureQuery(query);
        }
        return await query.FirstOrDefaultAsync(e => EF.Property<int>(e, "Id") == id);
    }
}

第二步：调用时传入多级预加载逻辑 #

现在你查询Question的时候，就可以轻松串联Include和ThenInclude了，完全不会有重复加载的问题：

// 假设_questionRepository是IGenericRepository<Question>的实例
var questions = await _questionRepository.GetAllAsync(query => 
    query.Include(q => q.Answers)  // 预加载Question的Answers
         .ThenInclude(a => a.Votes) // 接着预加载每个Answer的Votes
);

// 或者查询单个Question
var singleQuestion = await _questionRepository.GetByIdAsync(questionId, query => 
    query.Include(q => q.Answers)
         .ThenInclude(a => a.Votes)
);

第三步：可选——封装特定业务的预加载方法 #

如果这个多级预加载的逻辑经常用到，你可以在特定实体的仓储（比如IQuestionRepository）里封装专门的方法，避免重复写Include逻辑：

// 定义特定仓储接口
public interface IQuestionRepository : IGenericRepository<Question>
{
    Task<List<Question>> GetQuestionsWithAnswersAndVotesAsync();
    Task<Question?> GetQuestionWithAnswersAndVotesAsync(int id);
}

// 实现特定仓储
public class QuestionRepository : GenericRepository<Question>, IQuestionRepository
{
    public QuestionRepository(DbContext dbContext) : base(dbContext) { }

    public async Task<List<Question>> GetQuestionsWithAnswersAndVotesAsync()
    {
        return await GetAllAsync(query => 
            query.Include(q => q.Answers)
                 .ThenInclude(a => a.Votes)
        );
    }

    public async Task<Question?> GetQuestionWithAnswersAndVotesAsync(int id)
    {
        return await GetByIdAsync(id, query => 
            query.Include(q => q.Answers)
                 .ThenInclude(a => a.Votes)
        );
    }
}

为什么能解决重复加载的问题？ #

之前的重复加载，本质是因为没有正确串联多级预加载，导致EF Core的实体跟踪上下文里，同一个实体被多次加载（比如先加载Question+Answers，再单独加载Answers+Votes）。而通过Include+ThenInclude的链式调用，EF Core会生成一条包含所有关联表的SQL查询，一次性加载完整的实体树，自然不会出现重复加载的冲突。

额外排查小技巧 #

• 开启EF Core的SQL日志，查看生成的查询语句，确认是否是一次性加载所有关联数据，而不是多次查询。
• 确保你的DbContext是作用域内唯一的（比如ASP.NET Core里默认的Scoped生命周期），避免多个上下文实例导致的实体跟踪冲突。

内容的提问来源于stack exchange，提问作者Tan Sang