如何对EF Core导航属性执行集合操作？排查Npgsql过滤异常

问题根源 #

你遇到的ArgumentNullException确实和Npgsql的SQL翻译能力直接相关：

• 内存测试时用的是LINQ to Objects，Enumerable.IntersectBy和Count这类集合方法能直接在内存执行，所以逻辑正常。
• 但EF Core需要将表达式树翻译成PostgreSQL可执行的SQL，而Npgsql目前不支持将IntersectBy方法翻译为SQL，翻译过程中解析失败，进而抛出参数为空的异常。

另外你当前的表达式树逻辑依赖内存集合操作，完全不适合数据库查询场景——数据库层面的集合过滤应该用关联查询/EXISTS子查询，而非内存式的集合交集计算。

正确的导航属性集合过滤方式 #

EF Core和Npgsql对Any+Contains的组合有完美的SQL翻译支持，这是处理导航属性集合过滤的标准方案。针对你的ValueListFilterType，可以重新实现表达式树生成逻辑：

重构后的GetValueListFilteringOnListExpression方法 #

public static Expression? GetValueListFilteringOnListExpression<TProfile, TListItem, TListItemProp>(
    ValueFilter<TListItemProp>? filter, 
    string listPropertyName, 
    string listItemPropertyName, 
    ParameterExpression parameter) 
    where TProfile : class, IProfile
{
    if (filter == null || filter.ValueList == null || !filter.ValueList.Any())
        return null;

    var profileType = typeof(TProfile);
    var listProperty = profileType.GetProperty(listPropertyName);
    var listItemType = typeof(TListItem);
    var listItemProp = listItemType.GetProperty(listItemPropertyName);

    if (listProperty == null || listItemProp == null)
        return null;

    // 获取导航属性访问表达式：player => player.Heroes
    var listAccessExpr = Expression.MakeMemberAccess(parameter, listProperty);
    // 创建列表项参数：h => ...
    var listItemParam = Expression.Parameter(listItemType, "item");
    // 获取列表项属性访问表达式：h => h.Id
    var listItemPropAccess = Expression.MakeMemberAccess(listItemParam, listItemProp);
    // 过滤用的ID列表常量
    var valueListConst = Expression.Constant(filter.ValueList);

    // 获取Enumerable.Contains方法
    var containsMethod = typeof(Enumerable)
        .GetMethod(nameof(Enumerable.Contains))
        ?.MakeGenericMethod(typeof(TListItemProp));

    if (containsMethod == null)
        return null;

    // 构建：item => filter.ValueList.Contains(item.Id)
    var containsExpr = Expression.Call(
        containsMethod,
        valueListConst,
        listItemPropAccess);

    // 获取Enumerable.Any方法
    var anyMethod = typeof(Enumerable)
        .GetMethods()
        .Single(m => m.Name == nameof(Enumerable.Any) && m.GetParameters().Length == 2)
        .MakeGenericMethod(listItemType);

    // 构建：Heroes.Any(item => filter.ValueList.Contains(item.Id))
    var anyExpr = Expression.Call(
        anyMethod,
        listAccessExpr,
        Expression.Lambda(containsExpr, listItemParam));

    Expression finalExpr = null;
    var valueListCount = filter.ValueList.Count;

    switch (filter.FilterType)
    {
        case ValueListFilterType.Any:
            // 只要有匹配的Hero即可
            finalExpr = anyExpr;
            break;

        case ValueListFilterType.Excluding:
            // 完全没有匹配的Hero
            finalExpr = Expression.Not(anyExpr);
            break;

        case ValueListFilterType.Including:
            // 所有过滤的HeroID都在Player的Heroes中
            var allMatchExprs = new List<Expression>();
            foreach (var id in filter.ValueList)
            {
                var idConst = Expression.Constant(id);
                // 构建：item => item.Id == id
                var equalsExpr = Expression.Equal(listItemPropAccess, idConst);
                // 构建：Heroes.Any(item => item.Id == id)
                var singleAnyExpr = Expression.Call(
                    anyMethod,
                    listAccessExpr,
                    Expression.Lambda(equalsExpr, listItemParam));
                allMatchExprs.Add(singleAnyExpr);
            }
            // 所有条件用AndAlso连接
            finalExpr = allMatchExprs.Aggregate((a, b) => Expression.AndAlso(a, b));
            break;

        case ValueListFilterType.Exact:
            // 双向验证：1. Player的所有Hero都在过滤列表中；2. 过滤列表的所有ID都在Player的Heroes中
            var allHeroInListExpr = Expression.Call(
                typeof(Enumerable)
                    .GetMethods()
                    .Single(m => m.Name == nameof(Enumerable.All) && m.GetParameters().Length == 2)
                    .MakeGenericMethod(listItemType),
                listAccessExpr,
                Expression.Lambda(containsExpr, listItemParam));

            var allListInHeroExpr = new List<Expression>();
            foreach (var id in filter.ValueList)
            {
                var idConst = Expression.Constant(id);
                var equalsExpr = Expression.Equal(listItemPropAccess, idConst);
                var singleAnyExpr = Expression.Call(
                    anyMethod,
                    listAccessExpr,
                    Expression.Lambda(equalsExpr, listItemParam));
                allListInHeroExpr.Add(singleAnyExpr);
            }

            finalExpr = Expression.AndAlso(
                allHeroInListExpr,
                allListInHeroExpr.Aggregate((a, b) => Expression.AndAlso(a, b)));
            break;
    }

    return finalExpr;
}

关键改进点 #

1. 用Any替代IntersectBy：Heroes.Any(...)会被Npgsql翻译成SQL的EXISTS子查询，这是数据库层面高效的关联过滤方式。
2. 用Contains处理列表匹配：filter.ValueList.Contains(item.Id)会被翻译成SQL的IN子句（或= ANY(...)），完全符合PostgreSQL语法。
3. 避免内存集合操作：所有逻辑都基于数据库能理解的关联查询，而非内存中的集合交集计算。

额外注意事项 #

• 如果filter.ValueList为空，直接返回null，避免生成无效SQL。
• 调试时可以通过query.ToQueryString()查看生成的SQL，确认是否符合预期。
• 对于Exact类型的过滤，双向验证能确保Player的Hero集合和过滤列表完全匹配，避免遗漏情况。

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