求助：.NET Entity Framework中动态构建姓名拼接Lambda表达式

需求描述 #

需要构造如下形式的动态Lambda表达式，用于EF的Where子句：

u => (u.FirstName + " " + u.LastName).Contains("anyval")

但在构建(u.FirstName + " " + u.LastName)部分的表达式树时遇到问题。

已尝试方案 #

1️⃣ 使用Expression.Call调用string.Concat #

• 生成的SQL包含CONCAT()函数，但Entity Framework无法在Where子句中识别该函数（注：可能与EF版本相关）。

2️⃣ 使用Expression.Add链式拼接字符串 #

• 生成表达式((u.FirstName + " ") + u.LastName)，但未正确处理字符串运算符重载，导致EF无法正常解析。

已尝试代码 #

var parameter = Expression.Parameter(typeof(ApplicationUser), "u");
var firstNameProperty = Expression.PropertyOrField(parameter, "FirstName");
var lastNameProperty = Expression.PropertyOrField(parameter, "LastName");
var spaceConstant = Expression.Constant(" ");
var plusConstant = Expression.Constant("+");

// 构造(u.FirstName + " " + u.LastName)
var firstNamePlusSpace = Expression.Call(
typeof(string).GetMethod("Concat", new[] { typeof(string), typeof(string) }),
Expression.Call(
typeof(string).GetMethod("Concat", new[] { typeof(string), typeof(string) }),
firstNameProperty, plusConstant
),
Expression.Call(
typeof(string).GetMethod("Concat", new[] { typeof(string), typeof(string) }),
spaceConstant, lastNameProperty
)
);

var fullNameExpression = Expression.Call(
typeof(string).GetMethod("Concat", new[] { typeof(string), typeof(string) }),
firstNamePlusSpace, lastNameProperty
);

// 创建lambda表达式
var lambda = Expression.Lambda<Func<ApplicationUser, string>>(fullNameExpression, parameter);

// 将表达式传入GetCondition方法
return GetCondition<ApplicationUser>(null, condition, value, lambda);

// 辅助方法
private static MemberExpression GetMemberExpression(Expression param, string propertyName)
{
    if (propertyName.Contains("."))
    {
        int index = propertyName.IndexOf(".");
        var subParam = Expression.Property(param, propertyName.Substring(0, index));
        return GetMemberExpression(subParam, propertyName.Substring(index + 1));
    }
    return Expression.Property(param, propertyName);
}

private static Expression<Func<T, bool>> GetCondition<T>(string propertyName, string condition, string value, Expression<Func<ApplicationUser, string>> lambdaExp = null)
{
    var parameter = Expression.Parameter(typeof(T), "u");
    var property = (lambdaExp == null) ? GetMemberExpression(parameter, propertyName) : lambdaExp.Body;
    var constant = Expression.Constant(value);

    switch (condition.ToLower())
    {
        case "contains":
            return Expression.Lambda<Func<T, bool>>(
                Expression.Call(property, nameof(string.Contains), null, constant),
                parameter);
        case "doesnotcontain":
            return Expression.Lambda<Func<T, bool>>(
                Expression.Not(Expression.Call(property, nameof(string.Contains), null, constant)),
                parameter);
        case "startswith":
            return Expression.Lambda<Func<T, bool>>(
                Expression.Call(property, nameof(string.StartsWith), null, constant),
                parameter);
        case "endswith":
            return Expression.Lambda<Func<T, bool>>(
                Expression.Call(property, nameof(string.EndsWith), null, constant),
                parameter);
        case "=":
            return Expression.Lambda<Func<T, bool>>(
                Expression.Equal(property, constant),
                parameter);
        default:
            return null;
    }
}

问题与预期效果 #

问题：尝试的两种拼接方式生成的表达式树均无法被Entity Framework正确解析为可执行的SQL查询。
预期效果：生成的Lambda表达式能被EF转换为有效SQL，实现对拼接后完整姓名的过滤。

解决方案：正确构建姓名拼接表达式树 #

方法1：使用字符串运算符重载（对应C#的+） #

通过Expression.Add并指定字符串的加法运算符方法，模拟C#中的字符串拼接逻辑，EF会将其转换为SQL中的字符串拼接语法（如SQL Server的+）：

var parameter = Expression.Parameter(typeof(ApplicationUser), "u");

// 获取属性表达式
var firstNameExpr = Expression.Property(parameter, nameof(ApplicationUser.FirstName));
var lastNameExpr = Expression.Property(parameter, nameof(ApplicationUser.LastName));
var spaceExpr = Expression.Constant(" ");

// 获取字符串加法运算符的MethodInfo
var stringAddMethod = typeof(string).GetMethod("op_Addition", new[] { typeof(string), typeof(string) });

// 构造 (FirstName + " ")
var firstNamePlusSpace = Expression.Add(firstNameExpr, spaceExpr, stringAddMethod);
// 构造 ((FirstName + " ") + LastName)
var fullNameExpr = Expression.Add(firstNamePlusSpace, lastNameExpr, stringAddMethod);

// 构建Contains调用
var containsMethod = typeof(string).GetMethod(nameof(string.Contains), new[] { typeof(string) });
var valueConstant = Expression.Constant("anyval");
var containsCall = Expression.Call(fullNameExpr, containsMethod, valueConstant);

// 最终Lambda表达式
var lambda = Expression.Lambda<Func<ApplicationUser, bool>>(containsCall, parameter);

方法2：调用string.Concat多参数方法（适用于支持CONCAT函数的EF版本） #

如果你的EF版本（如EF Core 2.0+、EF6.1+）支持SQL的CONCAT函数，可以直接调用string.Concat的三参数重载，EF会转换为SQL的CONCAT函数：

var parameter = Expression.Parameter(typeof(ApplicationUser), "u");

var firstNameExpr = Expression.Property(parameter, nameof(ApplicationUser.FirstName));
var lastNameExpr = Expression.Property(parameter, nameof(ApplicationUser.LastName));
var spaceExpr = Expression.Constant(" ");

// 获取string.Concat(string, string, string)方法
var concatMethod = typeof(string).GetMethod("Concat", new[] { typeof(string), typeof(string), typeof(string) });
var fullNameExpr = Expression.Call(concatMethod, firstNameExpr, spaceExpr, lastNameExpr);

// 构建Contains调用
var containsMethod = typeof(string).GetMethod(nameof(string.Contains), new[] { typeof(string) });
var valueConstant = Expression.Constant("anyval");
var containsCall = Expression.Call(fullNameExpr, containsMethod, valueConstant);

var lambda = Expression.Lambda<Func<ApplicationUser, bool>>(containsCall, parameter);

适配现有GetCondition方法 #

如果要将上述拼接表达式传入你现有的GetCondition方法，需要解决参数表达式不匹配的问题，可通过参数替换实现：

private static Expression<Func<T, bool>> GetCondition<T>(string propertyName, string condition, string value, Expression<Func<T, string>> lambdaExp = null)
{
    var parameter = Expression.Parameter(typeof(T), "u");
    Expression propertyExpr;

    if (lambdaExp != null)
    {
        // 替换lambda表达式中的参数为当前方法的parameter，避免参数不匹配
        var parameterReplacer = new ParameterReplacer(lambdaExp.Parameters[0], parameter);
        propertyExpr = parameterReplacer.Visit(lambdaExp.Body);
    }
    else
    {
        propertyExpr = GetMemberExpression(parameter, propertyName);
    }

    var constant = Expression.Constant(value);

    switch (condition.ToLower())
    {
        case "contains":
            return Expression.Lambda<Func<T, bool>>(
                Expression.Call(propertyExpr, nameof(string.Contains), null, constant),
                parameter);
        // 其他case保持不变
        default:
            return null;
    }
}

// 参数替换辅助类
private class ParameterReplacer : ExpressionVisitor
{
    private readonly ParameterExpression _oldParam;
    private readonly ParameterExpression _newParam;

    public ParameterReplacer(ParameterExpression oldParam, ParameterExpression newParam)
    {
        _oldParam = oldParam;
        _newParam = newParam;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        return node == _oldParam ? _newParam : base.VisitParameter(node);
    }
}

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