Entity Framework中如何复用实体A的Include/ThenInclude查询逻辑？

刚接触Entity Framework，拥有一个与其他实体存在多对多关系的实体A。

在获取实体A的仓储中，使用了以下代码：

_dbContext.Set<A>().Where(a => a.Id == id).Include(a => a.B).ThenInclude(b=>b.C).Include(a=>a.D)
.SingleOrDefaultAsync();

在实体X的仓储中，使用了以下代码：

_dbContext.Set<X>().Where(x => x.Id == id).Include(x=>x.As).ThenInclude(a => a.B).ThenInclude(b=>b.C)
.Include(x=>x.As).Include(a=>a.D).SingleOrDefaultAsync();

若针对实体Y和Z，也需要编写相同的Include/ThenInclude逻辑。请问是否可以将这些Include逻辑统一维护在一处，以供不同仓储复用？

当然可以，以下是几种实用的统一维护方案：

1. 扩展方法封装（推荐） #

创建静态扩展方法类，将实体A的完整关联包含逻辑封装起来，后续直接调用即可：

封装包含逻辑 #

public static class QueryableExtensions
{
    // 针对单个A实体的完整关联包含
    public static IQueryable<A> IncludeFullAGraph(this IQueryable<A> query)
    {
        return query
            .Include(a => a.B).ThenInclude(b => b.C)
            .Include(a => a.D);
    }

    // 针对包含A集合的实体（如X/Y/Z）的完整关联包含
    public static IQueryable<T> IncludeFullAsGraph<T>(this IQueryable<T> query) 
        where T : class, IHasAsCollection
    {
        return query
            .Include(t => t.As).ThenInclude(a => a.B).ThenInclude(b => b.C)
            .Include(t => t.As).ThenInclude(a => a.D);
    }
}

// 定义通用接口，让X/Y/Z实现该接口
public interface IHasAsCollection
{
    ICollection<A> As { get; }
}

复用示例 #

• 实体A的仓储中简化调用：

_dbContext.Set<A>().Where(a => a.Id == id).IncludeFullAGraph().SingleOrDefaultAsync();

• 实体X/Y/Z的仓储中简化调用（需先实现IHasAsCollection接口）：

_dbContext.Set<X>().Where(x => x.Id == id).IncludeFullAsGraph().SingleOrDefaultAsync();

这种方式灵活度高，无需修改现有仓储结构，所有包含逻辑集中在静态类中，修改时只需改动一处即可全局生效。

2. 仓储基类复用 #

如果所有仓储都继承自同一个基类，可以在基类中封装通用方法：

public class BaseRepository<T> where T : class
{
    protected readonly DbContext _dbContext;

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

    // 通用方法：获取包含完整A集合关联的实体
    protected IQueryable<TEntity> GetEntityWithFullAs<TEntity>(Expression<Func<TEntity, bool>> predicate) 
        where TEntity : class, IHasAsCollection
    {
        return _dbContext.Set<TEntity>()
            .Where(predicate)
            .Include(t => t.As).ThenInclude(a => a.B).ThenInclude(b => b.C)
            .Include(t => t.As).ThenInclude(a => a.D);
    }
}

之后X/Y/Z的仓储继承该基类，直接调用封装好的方法即可：

public class XRepository : BaseRepository<X>
{
    public XRepository(DbContext dbContext) : base(dbContext) { }

    public async Task<X> GetByIdWithFullAsAsync(int id)
    {
        return await GetEntityWithFullAs(x => x.Id == id).SingleOrDefaultAsync();
    }
}

3. 预定义表达式树（备选） #

可以将包含逻辑定义为表达式数组，不过这种方式处理ThenInclude相对繁琐，适合简单场景：

public static class EntityIncludeExpressions
{
    // 实体A的包含表达式
    public static readonly Expression<Func<A, object>>[] AIncludes = 
    {
        a => a.B,
        a => a.D
    };
}

使用时可以循环添加Include，但ThenInclude需要额外处理，因此不如扩展方法便捷。

内容的提问来源于stack exchange，提问作者3lwan