如何在MakeComparison中添加Or/OrElse与In操作？含错误排查

核心问题拆解 #

1. Or/OrElse逻辑错误：你把Or/OrElse当作属性与值的比较运算符处理，但它们本质是布尔条件表达式的组合运算符，要求左右操作数都是bool类型，而非属性类型（比如Nullable<Int16>），这直接触发了类型不匹配的报错。
2. In操作未实现：需要单独处理集合包含逻辑，通过调用Enumerable.Contains方法生成对应表达式。
3. 生成And而非Or的假象：大概率是你在组合条件时错误地用And合并了所有表达式，而非用Or/OrElse组合独立的布尔条件。

代码修正与扩展 #

1. 拆分逻辑：区分比较运算符与条件组合运算符 #

移除MakeComparison中Or/OrElse的分支，新增专门用于组合布尔条件的方法：

// 组合两个布尔表达式（支持Or/OrElse/And/AndAlso）
private static Expression<Func<T, bool>> CombineConditions<T>(
    Expression<Func<T, bool>> leftCondition,
    Expression<Func<T, bool>> rightCondition,
    ExpressionType combineType)
{
    var parameter = Expression.Parameter(typeof(T));
    // 替换表达式参数，确保两个条件使用同一参数实例
    var leftBody = ReplaceParameter(leftCondition.Body, leftCondition.Parameters[0], parameter);
    var rightBody = ReplaceParameter(rightCondition.Body, rightCondition.Parameters[0], parameter);
    
    var combinedBody = Expression.MakeBinary(combineType, leftBody, rightBody);
    return Expression.Lambda<Func<T, bool>>(combinedBody, parameter);
}

// 辅助方法：替换表达式中的参数
private static Expression ReplaceParameter(Expression expression, ParameterExpression oldParam, ParameterExpression newParam)
{
    return new ParameterReplacer(oldParam, newParam).Visit(expression);
}

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

2. 添加In操作支持 #

修改MakeComparison方法，新增In分支并实现对应的表达式生成逻辑：

private static Expression MakeComparison(Expression left, string comparison, string value)
{
    switch (comparison)
    {
        case "==":
        case "IsEqualTo":
            return MakeBinary(ExpressionType.Equal, left, value);
        case "!=":
        case "IsNotEqualTo":
            return MakeBinary(ExpressionType.NotEqual, left, value);
        case ">":
        case "IsGreaterThan":
            return MakeBinary(ExpressionType.GreaterThan, left, value);
        case ">=":
        case "IsGreaterThanOrEqualTo":
            return MakeBinary(ExpressionType.GreaterThanOrEqual, left, value);
        case "<":
        case "IsLessThan":
            return MakeBinary(ExpressionType.LessThan, left, value);
        case "<=":
        case "IsLessThanOrEqualTo":
            return MakeBinary(ExpressionType.LessThanOrEqual, left, value);
        case "Contains":
        case "StartsWith":
        case "EndsWith":
            return Expression.Call(MakeString(left), comparison, Type.EmptyTypes, Expression.Constant(value, typeof(string)));
        case "In":
            return MakeInExpression(left, value); // 新增In逻辑
        default:
            throw new NotSupportedException($"Invalid comparison operator '{comparison}'.");
    }
}

// 生成In操作表达式：检查属性是否在指定集合中
private static Expression MakeInExpression(Expression left, string valuesString)
{
    var values = valuesString.Split(',', StringSplitOptions.RemoveEmptyEntries);
    var elementType = Nullable.GetUnderlyingType(left.Type) ?? left.Type;
    
    // 将字符串值转换为对应类型的集合
    var typedValues = values.Select(v => 
        elementType.IsEnum ? Enum.Parse(elementType, v.Trim()) :
        elementType == typeof(Guid) ? Guid.Parse(v.Trim()) :
        Convert.ChangeType(v.Trim(), elementType)
    ).ToList();
    
    // 创建集合常量表达式
    var collectionType = typeof(IEnumerable<>).MakeGenericType(elementType);
    var collectionConstant = Expression.Constant(typedValues, collectionType);
    
    // 调用Enumerable.Contains方法
    return Expression.Call(
        typeof(Enumerable),
        "Contains",
        new[] { elementType },
        collectionConstant,
        left
    );
}

3. 保留原有MakeBinary方法 #

你的MakeBinary方法处理普通比较逻辑是正常的，无需修改。

正确使用示例 #

组合OrElse条件 #

var param = Expression.Parameter(typeof(YourEntity), "x");
// 生成两个独立的布尔条件
var condition1 = Expression.Lambda<Func<YourEntity, bool>>(
    MakeComparison(Expression.Property(param, "Age"), "IsEqualTo", "18"), param);
var condition2 = Expression.Lambda<Func<YourEntity, bool>>(
    MakeComparison(Expression.Property(param, "Age"), "IsEqualTo", "20"), param);

// 用OrElse组合两个条件
var combinedCondition = CombineConditions(condition1, condition2, ExpressionType.OrElse);

使用In操作 #

var param = Expression.Parameter(typeof(YourEntity), "x");
// 生成Age在{18,20,22}中的条件
var inCondition = MakeComparison(Expression.Property(param, "Age"), "In", "18,20,22");
var lambda = Expression.Lambda<Func<YourEntity, bool>>(inCondition, param);

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