EF Core中AutoInclude结合筛选Include的实现方案咨询

我想实现类似某GitHub评论中提到的筛选Include配置，原提议写法是在NavigationBuilder上添加筛选逻辑：

modelBuilder.Entity<Student>().Navigation(e => e.Courses).HasIncludeFilter(e => e.Where(course => course.Difficulty >10));

但实际使用Navigation()搭配AutoInclude()时，并不支持这种带筛选的Include。我尝试在泛型实体配置里获取翻译条目或回退项，代码如下：

public override void Configure(EntityTypeBuilder<TTranslatable> builder) {
    builder.HasMany(p => p.Translations)
      .WithOne(c => c.Parent)
      .HasForeignKey(c => c.ParentId)
      .IsRequired()
      .OnDelete(DeleteBehavior.Cascade);
  
    builder.Navigation(
       p => p.Translations.Where(t => t.Language == requestLanguage || t.IsDefaultLanguage == true)
         .OrderBy(t => t.IsDefaultLanguage)
         .Take(1)
       )
       .AutoInclude();

    base.Configure(builder);
  }

这段代码能编译，但运行时会抛出异常，要求移除Where、OrderBy、Take子句，只允许引用简单的p => p.Translations。

请问有没有不用在每个查询里重复编写筛选Include的实现方式？

可行替代方案 #

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

创建一个DbSet的扩展方法，把筛选Include的逻辑封装起来，每次查询直接调用即可：

public static IQueryable<T> IncludeFilteredTranslation<T>(this IQueryable<T> query, string targetLanguage) 
    where T : class, ITranslatable
{
    return query.Include(entity => entity.Translations)
                .Where(entity => entity.Translations.Any(t => 
                    t.Language == targetLanguage || t.IsDefaultLanguage))
                .Select(entity => new 
                {
                    Entity = entity,
                    FilteredTranslation = entity.Translations
                        .Where(t => t.Language == targetLanguage || t.IsDefaultLanguage)
                        .OrderBy(t => t.IsDefaultLanguage)
                        .Take(1)
                })
                .Select(x => x.Entity);
}

使用示例：

var result = dbContext.Products.IncludeFilteredTranslation("zh-CN").ToList();

2. 实体类添加计算属性（EF Core 6+） #

在你的可翻译实体里添加一个计算属性，直接返回筛选后的翻译项，同时配置该属性不映射到数据库：

public class Product : ITranslatable
{
    public int Id { get; set; }
    public ICollection<ProductTranslation> Translations { get; set; } = new List<ProductTranslation>();
    
    // 计算属性，返回匹配语言或默认的翻译
    [NotMapped]
    public ProductTranslation CurrentTranslation => Translations
        .Where(t => t.Language == CurrentLanguage || t.IsDefaultLanguage)
        .OrderBy(t => t.IsDefaultLanguage)
        .FirstOrDefault();

    // 静态属性存储当前语言，可根据业务场景动态设置
    public static string CurrentLanguage { get; set; } = "en";
}

查询时直接访问CurrentTranslation，EF Core会自动生成对应的关联查询逻辑。

3. 全局查询过滤器（仅适用于固定筛选条件） #

如果你的筛选条件是全局固定的（比如始终取默认语言），可以给翻译实体添加全局查询过滤器：

modelBuilder.Entity<ProductTranslation>()
    .HasQueryFilter(t => t.IsDefaultLanguage == true);

注意：这种方式会影响所有涉及翻译实体的查询，无法动态切换筛选条件。

4. 自定义查询拦截器（动态筛选场景） #

创建查询拦截器，在查询编译阶段自动给指定导航属性添加筛选逻辑，适合需要动态切换条件的场景：

public class TranslationFilterInterceptor : IQueryExpressionInterceptor
{
    private readonly string _currentLanguage;

    public TranslationFilterInterceptor(string currentLanguage)
    {
        _currentLanguage = currentLanguage;
    }

    public Expression QueryCompilationStarting(Expression queryExpression, QueryExpressionEventData eventData)
    {
        // 遍历表达式树，找到Translations导航属性的Include节点，替换为带筛选的版本
        return new TranslationFilterExpressionVisitor(_currentLanguage).Visit(queryExpression);
    }
}

// 自定义表达式访问器实现替换逻辑
public class TranslationFilterExpressionVisitor : ExpressionVisitor
{
    private readonly string _language;

    public TranslationFilterExpressionVisitor(string language)
    {
        _language = language;
    }

    // 重写Visit方法，处理Include表达式
    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        // 判断是否是Include方法，且目标是Translations导航属性
        if (node.Method.Name == "Include" && node.Arguments.Count == 2)
        {
            var navigationExpr = node.Arguments[1] as LambdaExpression;
            if (navigationExpr?.Body is MemberExpression memberExpr 
                && memberExpr.Member.Name == "Translations")
            {
                // 构建带筛选的导航属性表达式
                var parameter = navigationExpr.Parameters[0];
                var filteredExpr = Expression.Call(
                    typeof(Enumerable),
                    "Where",
                    new[] { typeof(Translation) },
                    Expression.Property(parameter, "Translations"),
                    Expression.Lambda<Func<Translation, bool>>(
                        Expression.OrElse(
                            Expression.Equal(Expression.Property(Expression.Parameter(typeof(Translation)), "Language"), Expression.Constant(_language)),
                            Expression.Equal(Expression.Property(Expression.Parameter(typeof(Translation)), "IsDefaultLanguage"), Expression.Constant(true))
                        ),
                        Expression.Parameter(typeof(Translation))
                    )
                );
                // 替换原Include的表达式
                var newLambda = Expression.Lambda(filteredExpr, parameter);
                return Expression.Call(node.Object, node.Method, node.Arguments[0], newLambda);
            }
        }
        return base.VisitMethodCall(node);
    }
}

注册拦截器到DbContext：

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.AddInterceptors(new TranslationFilterInterceptor("zh-CN"));
}

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