EF Core Where子句复用多参数返回int表达式遇编译错误

你遇到的CS0149错误，是因为你把Expression<Func<Build, Build, int>>类型的变量当成普通方法直接调用了。表达式树本质是描述逻辑的数据结构，不是可执行的方法，EF Core无法解析这种调用方式。

下面提供两种可行的解决方案，既能复用Build比较逻辑，又能保证EF Core将其转换为SQL：

方案一：使用可翻译的静态比较方法 #

这是最简单的实现方式，把Build比较逻辑封装成静态方法，EF Core会自动解析方法内的逻辑并转换为SQL（只要方法内的操作都是EF Core支持的SQL转换）。

// 封装比较逻辑到静态类
public static class BuildComparer
{
    // 确保方法内的逻辑是EF Core能转换为SQL的（比如这里的Version比较）
    public static int Compare(Build first, Build second)
    {
        return first.Version == second.Version ? 0 : (first.Version < second.Version ? -1 : 1);
    }
}

// 修改查询方法
public List<Ticket> GetTicketsForBuild(Build build)
{
    return _myDbContext.Ticket
        .Where(x => BuildComparer.Compare(x.BuildIntroducedIn, build) <= 0)
        .Where(x => x.IsPublic 
            ? BuildComparer.Compare(x.BuildResolvedIn, build) < 0 
            : BuildComparer.Compare(x.BuildResolvedIn, build) > 0)
        .ToList();
}

注意事项 #

• 确保比较逻辑中的所有操作都能被EF Core 3.1和Npgsql 4.1.9识别（比如基础类型比较、简单条件判断）。
• 不要在方法中加入EF Core无法翻译的操作（比如自定义类型的私有方法、未映射的实体属性等）。

方案二：表达式树拼接（适合复杂场景） #

如果你的比较逻辑非常复杂，或者需要更灵活的表达式复用，可以通过表达式树拼接的方式，把比较逻辑嵌入到查询的lambda表达式中。需要用到ReplacingExpressionVisitor来替换表达式中的参数：

using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore.Query;

// 辅助扩展方法：替换表达式中的第二个参数为常量
public static class ExpressionExtensions
{
    public static Expression<Func<T, TResult>> ReplaceSecondParameterWithConstant<T, U, TResult>(
        this Expression<Func<T, U, TResult>> expression, U constantValue)
    {
        var param = expression.Parameters[0];
        var constantExpr = Expression.Constant(constantValue, typeof(U));
        // 替换表达式中的第二个参数为常量
        var newBody = ReplacingExpressionVisitor.Replace(expression.Parameters[1], constantExpr, expression.Body);
        return Expression.Lambda<Func<T, TResult>>(newBody, param);
    }
}

// 修改查询方法
public List<Ticket> GetTicketsForBuild(Build build)
{
    // 定义通用的比较表达式（参数1：待比较的Build，参数2：目标Build）
    Expression<Func<Build, Build, int>> compareBuilds = (first, second) =>
        first.Version == second.Version ? 0 : (first.Version < second.Version ? -1 : 1);

    // 1. 构建"BuildIntroducedIn <= build"的过滤表达式
    var compareIntroduced = compareBuilds.ReplaceSecondParameterWithConstant(build);
    var filterIntroduced = Expression.Lambda<Func<Ticket, bool>>(
        Expression.LessThanOrEqual(
            Expression.Invoke(compareIntroduced, Expression.PropertyOrField(Expression.Parameter(typeof(Ticket)), "BuildIntroducedIn")),
            Expression.Constant(0)
        ),
        Expression.Parameter(typeof(Ticket))
    );

    // 2. 构建"BuildResolvedIn"的条件过滤表达式
    var compareResolved = compareBuilds.ReplaceSecondParameterWithConstant(build);
    var resolvedLessThanZero = Expression.LessThan(
        Expression.Invoke(compareResolved, Expression.PropertyOrField(Expression.Parameter(typeof(Ticket)), "BuildResolvedIn")),
        Expression.Constant(0)
    );
    var resolvedGreaterThanZero = Expression.GreaterThan(
        Expression.Invoke(compareResolved, Expression.PropertyOrField(Expression.Parameter(typeof(Ticket)), "BuildResolvedIn")),
        Expression.Constant(0)
    );
    var filterResolved = Expression.Lambda<Func<Ticket, bool>>(
        Expression.Condition(
            Expression.PropertyOrField(Expression.Parameter(typeof(Ticket)), "IsPublic"),
            resolvedLessThanZero,
            resolvedGreaterThanZero
        ),
        Expression.Parameter(typeof(Ticket))
    );

    // 组合两个过滤条件
    var finalFilter = Expression.Lambda<Func<Ticket, bool>>(
        Expression.AndAlso(filterIntroduced.Body, filterResolved.Body),
        filterIntroduced.Parameters[0]
    );

    return _myDbContext.Ticket.Where(finalFilter).ToList();
}

这种方式适合需要高度复用表达式逻辑的场景，但代码复杂度更高。

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