如何使用逻辑运算符组合两个表达式对象？

>本文探讨了使用C＃中逻辑运算符组合两个对象的方法。 直接使用Expression<func>></func>或AND>是不可能的。相反，使用OR，Expression.AndAlso和OrElse。 当表达式使用不同的参数时，复杂性会增加。 提出了三种解决方案：Not

>结合两个布尔表达式

挑战在于使用逻辑和或不使用两个对象组合两个对象。 一种简单的方法，例如

>是无效的。Expression<func>></func> expr1 AND expr2

solutions

几种方法解决以下方法：

方法1：使用

Invoke>

此方法利用

方法在公共参数上下文中执行每个表达式。Invoke>

static Expression<Func<bool>> AndAlso<T>(
    this Expression<Func<bool>> left,
    Expression<Func<bool>> right)
{
    var param = Expression.Parameter(typeof(T), "x");
    var body = Expression.AndAlso(
            Expression.Invoke(left, param),
            Expression.Invoke(right, param)
        );
    var lambda = Expression.Lambda<Func<bool>>(body, param);
    return lambda;
}

方法2：参数替换（条件）>

此方法检查表达式是否共享相同的参数。如果是这样，则使用更简单的

。否则，它使用第一个参数来调用第二个表达式。AndAlso>

static Expression<Func<bool>> AndAlso<T>(
    this Expression<Func<bool>> expr1,
    Expression<Func<bool>> expr2)
{
    ParameterExpression param = expr1.Parameters[0];
    if (ReferenceEquals(param, expr2.Parameters[0]))
    {
        return Expression.Lambda<Func<bool>>(
            Expression.AndAlso(expr1.Body, expr2.Body), param);
    }
    return Expression.Lambda<Func<bool>>(
        Expression.AndAlso(
            expr1.Body,
            Expression.Invoke(expr2, param)), param);
}

方法3：ExpressionVisitor>

这种复杂的方法采用

在一个表达式中系统地替换参数以匹配另一个参数，然后再应用ExpressionVisitor>。AndAlso。

public static Expression<Func<bool>> AndAlso<T>(
    this Expression<Func<bool>> expr1,
    Expression<Func<bool>> expr2)
{
    var parameter = Expression.Parameter(typeof(T));

    var leftVisitor = new ReplaceExpressionVisitor(expr1.Parameters[0], parameter);
    var left = leftVisitor.Visit(expr1.Body);

    var rightVisitor = new ReplaceExpressionVisitor(expr2.Parameters[0], parameter);
    var right = rightVisitor.Visit(expr2.Body);

    return Expression.Lambda<Func<bool>>(
        Expression.AndAlso(left, right), parameter);
}

private class ReplaceExpressionVisitor : ExpressionVisitor
{
    private readonly Expression _oldValue;
    private readonly Expression _newValue;

    public ReplaceExpressionVisitor(Expression oldValue, Expression newValue)
    {
        _oldValue = oldValue;
        _newValue = newValue;
    }

    public override Expression Visit(Expression node)
    {
        if (node == _oldValue)
            return _newValue;
        return base.Visit(node);
    }
}

方法的选择取决于表达式的复杂性和优化性能的需求。 方法1很简单，当参数匹配时，方法2提供了性能改进，方法3为处理不同参数提供了强大的解决方案。

以上是如何使用逻辑运算符组合两个表达式对象？的详细内容。更多信息请关注PHP中文网其他相关文章！