当T1与T2类型相同时，如何合并两个Expression<Func<T,bool>>的表达式体？

场景与问题 #

当你有两个表达式：

Expression<Func<T1, bool>> expr1; Expression<Func<T2, bool>> expr2;

在运行时typeof(T1) == typeof(T2)的情况下，想要用&&或||逻辑合并两个表达式的主体（而非合并表达式调用），但直接转换会触发以下错误：

错误提示：无法将类型为Expression<Func<T1, bool>>的变量强制转换为Expression<Func<T2, bool>>类型

这是因为即使T1和T2运行时类型一致，它们是编译时不同的泛型类型参数，无法直接强制转换；且两个表达式的参数实例是独立的，直接合并主体会导致参数不匹配。

最优解决方案 #

核心思路是：统一两个表达式的参数实例，再合并表达式主体。通过自定义ExpressionVisitor替换其中一个表达式的参数，使其与另一个表达式的参数一致，再生成新的合并表达式。

1. 实现参数替换访问器 #

public 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);
    }
}

2. 封装合并方法 #

public static Expression<Func<T, bool>> CombineExpressions<T>(
    Expression<Func<T, bool>> expr1,
    Expression<Func<T, bool>> expr2,
    Func<Expression, Expression, BinaryExpression> combineOperator)
{
    // 将expr2的参数替换为expr1的参数，确保参数实例一致
    var replacedExpr2Body = new ParameterReplacer(expr2.Parameters[0], expr1.Parameters[0]).Visit(expr2.Body);
    // 用指定逻辑运算符合并两个表达式主体
    var combinedBody = combineOperator(expr1.Body, replacedExpr2Body);
    // 生成新的合并表达式
    return Expression.Lambda<Func<T, bool>>(combinedBody, expr1.Parameters[0]);
}

3. 调用示例 #

Expression<Func<T1, bool>> expr1 = ...;
Expression<Func<T2, bool>> expr2 = ...;

if (typeof(T1) == typeof(T2))
{
    // 将expr2转换为T1类型的表达式（处理编译时类型差异）
    var typedExpr2 = expr2 as Expression<Func<T1, bool>> ?? 
                     Expression.Lambda<Func<T1, bool>>(expr2.Body, Expression.Parameter(typeof(T1), expr2.Parameters[0].Name));

    // 合并为 && 逻辑
    var combinedAndExpr = CombineExpressions(expr1, typedExpr2, Expression.AndAlso);
    // 合并为 || 逻辑
    var combinedOrExpr = CombineExpressions(expr1, typedExpr2, Expression.OrElse);
}

关键说明 #

• 不能直接强制转换：泛型表达式的类型是编译时确定的，即使T1和T2运行时类型相同，编译时仍属于不同类型，无法直接转换。
• 参数必须统一：两个表达式的ParameterExpression是独立实例，即使名称和类型相同，直接合并主体会导致表达式树中存在两个不同的参数，执行时会报错，因此必须通过ExpressionVisitor替换参数。

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