代码创建LINQ Lambda遇「参数无法转换」错误的技术问询

场景需求 #

现有Composition和Module两个实体，Composition包含多个Module子实体。从数据库查询Composition时，需要根据Composition的类型过滤关联的Module（避免加载全部子实体占用内存）。硬编码的实现可以生成正确的服务器端过滤SQL，但各Composition类型对应的Module过滤规则定义在领域模型中，需要通过代码动态生成过滤谓词。

硬编码示例代码：

EF_Repo.Compositions.Where(<some clause>)
    .Include(comp => comp.Modules.Where(m => 
        (m.Composition == "A" && new[] {"25", "51", "53"}.Contains(m.AlgNo))
        || (m.Composition == "B" && new[] {"15", "21"}.Contains(m.AlgNo))
    ));

问题重现 #

尝试手动构建简单的Expression<Func<Module, bool>>时，EF Core抛出错误："InvalidOperationException: The LINQ expression 'm' could not be translated."

出错代码：

void Main()
{
    Modules.Where(CreateLambda()).Take(100).Dump();
    // Modules.Where(m => m.AlgNo == "48").Take(100).Dump();
}

Expression<Func<LINQPad.User.Module, bool>> CreateLambda()
{
    var modpar = Expression.Parameter(typeof(LINQPad.User.Module), "m");
    var algnoProp = typeof(LINQPad.User.Module).GetProperty(nameof(LINQPad.User.Module.AlgNo));
    var ma = Expression.MakeMemberAccess(modpar, algnoProp);
    
    var no48 = Expression.Constant("48");
    var equality = Expression.Equal(no48, ma);
    
    // 错误点：重新创建了ParameterExpression，和之前的modpar不是同一个实例
    var lambda = Expression.Lambda<Func<LINQPad.User.Module, bool>>(equality, false, Expression.Parameter(typeof(LINQPad.User.Module), "m"));
    
    return lambda;
}

错误原因 #

创建Lambda表达式时，最后一步重新实例化了Expression.Parameter，导致Lambda的参数和表达式树中引用的modpar不是同一个实例。EF Core无法识别这种不一致的参数引用，因此无法翻译表达式。

修正方案 #

1. 修复简单Lambda的构建 #

将创建Lambda时的参数替换为之前定义的modpar实例：

Expression<Func<LINQPad.User.Module, bool>> CreateLambda()
{
    var modpar = Expression.Parameter(typeof(LINQPad.User.Module), "m");
    var algnoProp = typeof(LINQPad.User.Module).GetProperty(nameof(LINQPad.User.Module.AlgNo));
    var ma = Expression.MakeMemberAccess(modpar, algnoProp);
    
    var no48 = Expression.Constant("48");
    var equality = Expression.Equal(ma, no48); // 属性在前、常量在后更符合EF翻译习惯
    
    // 使用之前定义的modpar作为Lambda参数
    var lambda = Expression.Lambda<Func<LINQPad.User.Module, bool>>(equality, modpar);
    
    return lambda;
}

2. 扩展到复杂场景（动态生成多规则过滤） #

根据领域模型中的规则字典，动态构建包含多条件OrElse和Contains的表达式：

Expression<Func<Module, bool>> CreateDynamicModuleFilter()
{
    var modPar = Expression.Parameter(typeof(Module), "m");
    
    // 获取实体属性表达式
    var compositionProp = Expression.Property(modPar, nameof(Module.Composition));
    var algNoProp = Expression.Property(modPar, nameof(Module.AlgNo));
    
    // 领域模型中定义的规则（可从配置/领域服务获取）
    var compositionRules = new Dictionary<string, string[]>
    {
        {"A", new[] {"25", "51", "53"}},
        {"B", new[] {"15", "21"}}
    };
    
    Expression combinedCondition = null;
    
    foreach (var rule in compositionRules)
    {
        // 构建 m.Composition == "规则类型"
        var compositionMatch = Expression.Equal(compositionProp, Expression.Constant(rule.Key));
        
        // 构建 Enumerable.Contains(规则数组, m.AlgNo)
        var algNoMatch = Expression.Call(
            typeof(Enumerable),
            nameof(Enumerable.Contains),
            new[] { typeof(string) },
            Expression.Constant(rule.Value),
            algNoProp
        );
        
        // 组合当前规则的与条件：Composition匹配 && AlgNo在列表中
        var ruleCondition = Expression.AndAlso(compositionMatch, algNoMatch);
        
        // 组合所有规则的或条件：规则1 || 规则2 || ...
        combinedCondition = combinedCondition == null 
            ? ruleCondition 
            : Expression.OrElse(combinedCondition, ruleCondition);
    }
    
    return Expression.Lambda<Func<Module, bool>>(combinedCondition, modPar);
}

使用时直接将生成的表达式传入Include的Where中即可：

EF_Repo.Compositions.Where(<some clause>)
    .Include(comp => comp.Modules.Where(CreateDynamicModuleFilter()));

该方法生成的表达式树与硬编码版本结构完全一致，EF Core可以正确翻译为服务器端SQL。

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