EF Core查询主体时自动获取关联依赖项ID的实现方案问询

方案1：封装通用查询扩展方法 #

这是最直接高效的方案，既不用加载全量关联数据，也能避免重复编写Select逻辑，还能让基类统一调用。

1. 先在OnModelCreating中确保主体与依赖项的导航属性配置正确（无需启用AutoInclude）：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 示例：配置Principal与Dependent的一对多关联
    modelBuilder.Entity<Principal>()
        .HasMany(p => p.Dependents)
        .WithOne(d => d.Principal)
        .HasForeignKey(d => d.PrincipalId);
}

2. 编写通用查询扩展方法，自动投影主体数据+依赖项ID列表：

public static IQueryable<TPrincipal> WithDependentIds<TPrincipal, TDependent>(this IQueryable<TPrincipal> query)
    where TPrincipal : class, IHasDependents<TDependent>
    where TDependent : class, IHasId
{
    return query.Select(p => new 
    {
        Principal = p,
        DependentIds = p.Dependents.Select(d => d.Id).ToList()
    })
    .Select(result => 
    {
        // 假设Principal实体有DependentIds属性存储ID列表
        result.Principal.DependentIds = result.DependentIds;
        return result.Principal;
    });
}

// 定义通用接口规范实体结构
public interface IHasDependents<TDependent> where TDependent : IHasId
{
    IEnumerable<TDependent> Dependents { get; }
    List<int> DependentIds { get; set; }
}

public interface IHasId
{
    int Id { get; }
}

3. 在ServiceBase基类中统一调用该扩展：

public class ServiceBase<TPrincipal> where TPrincipal : class, IHasDependents<IHasId>
{
    protected readonly DbContext _context;

    public ServiceBase(DbContext context)
    {
        _context = context;
    }

    public virtual async Task<TPrincipal> GetByIdAsync(int id)
    {
        return await _context.Set<TPrincipal>()
            .WithDependentIds()
            .FirstOrDefaultAsync(p => ((dynamic)p).Id == id);
    }
}

方案2：结合模型元数据的自动投影（进阶） #

如果希望配置逻辑更贴近HasQueryFilter的方式，可以通过模型元数据存储配置信息，查询时自动应用投影：

1. 定义存储配置的扩展类与ModelBuilder扩展方法：

public class DependentIdProjectionConfig
{
    public LambdaExpression DependentSelector { get; set; }
    public LambdaExpression IdSelector { get; set; }
}

public static class ModelBuilderExtensions
{
    public static EntityTypeBuilder<TPrincipal> HasDependentIdProjection<TPrincipal, TDependent>(
        this EntityTypeBuilder<TPrincipal> entityBuilder,
        Expression<Func<TPrincipal, IEnumerable<TDependent>>> dependentSelector,
        Expression<Func<TDependent, int>> idSelector)
        where TPrincipal : class
        where TDependent : class
    {
        var config = new DependentIdProjectionConfig
        {
            DependentSelector = dependentSelector,
            IdSelector = idSelector
        };
        // 将配置附加到实体元数据
        entityBuilder.Metadata.AddAnnotation("DependentIdProjection", config);
        return entityBuilder;
    }
}

2. 在OnModelCreating中配置投影规则：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Principal>()
        .HasMany(p => p.Dependents)
        .WithOne(d => d.Principal)
        .HasForeignKey(d => d.PrincipalId)
        .HasDependentIdProjection(p => p.Dependents, d => d.Id);
}

3. 编写查询扩展方法，自动读取元数据并应用投影：

public static IQueryable<TPrincipal> ApplyDependentIdProjection<TPrincipal>(this IQueryable<TPrincipal> query)
    where TPrincipal : class
{
    var entityType = query.Provider.GetService<IDbContextServices>().Context.Model.FindEntityType(typeof(TPrincipal));
    if (entityType == null) return query;

    var config = entityType.FindAnnotation("DependentIdProjection")?.Value as DependentIdProjectionConfig;
    if (config == null) return query;

    // 通过表达式树动态构建投影逻辑，避免dynamic性能损耗
    var param = Expression.Parameter(typeof(TPrincipal), "p");
    var dependentAccess = Expression.Invoke(config.DependentSelector, param);
    var idSelector = Expression.Lambda(config.IdSelector.Body, config.IdSelector.Parameters);
    
    var selectIds = Expression.Call(typeof(Enumerable), "Select",
        new[] { config.DependentSelector.ReturnType.GenericTypeArguments[0], typeof(int) },
        dependentAccess, idSelector);
    var toList = Expression.Call(typeof(Enumerable), "ToList", new[] { typeof(int) }, selectIds);

    // 构建匿名类型投影并赋值回实体
    var anonType = new { Principal = default(TPrincipal), DependentIds = default(List<int>) }.GetType();
    var init = Expression.MemberInit(Expression.New(anonType),
        Expression.Bind(anonType.GetProperty("Principal"), param),
        Expression.Bind(anonType.GetProperty("DependentIds"), toList));

    var outerParam = Expression.Parameter(anonType, "result");
    var assign = Expression.Assign(
        Expression.Property(Expression.Property(outerParam, "Principal"), "DependentIds"),
        Expression.Property(outerParam, "DependentIds"));
    var outerBody = Expression.Block(assign, Expression.Property(outerParam, "Principal"));
    var outerLambda = Expression.Lambda<Func<object, TPrincipal>>(outerBody, outerParam);

    return query.Select(Expression.Lambda(init, param)).Select(outerLambda);
}

4. 基类中调用该扩展：

public virtual async Task<TPrincipal> GetByIdAsync(int id)
{
    return await _context.Set<TPrincipal>()
        .ApplyDependentIdProjection()
        .FirstOrDefaultAsync(p => ((dynamic)p).Id == id);
}

方案优势 #

• 避免AutoInclude()加载全量依赖实体，仅从数据库查询ID字段，大幅减少数据传输量
• 投影逻辑在数据库端执行（EF Core会转换为对应的SQL聚合查询），性能远优于内存中处理全量实体

内容的提问来源于stack exchange，提问作者Randy Hall