如何在不调用的情况下组合Expression<TDelegate>对象？

在不调用的情况下组合Expression<TDelegate>对象，可以通过使用ExpressionVisitor类来实现。ExpressionVisitor类是Expression类的派生类，可以用于遍历和修改表达式树。

以下是一个示例代码，展示如何组合Expression<TDelegate>对象：

using System;
using System.Linq.Expressions;

public class ExpressionCombiner : ExpressionVisitor
{
    private readonly ParameterExpression _parameter;

    public ExpressionCombiner(ParameterExpression parameter)
    {
        _parameter = parameter;
    }

    public Expression<Func<T, bool>> Combine<T>(Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
    {
        var body1 = RebindParameter(expr1.Body, expr1.Parameters[0], _parameter);
        var body2 = RebindParameter(expr2.Body, expr2.Parameters[0], _parameter);

        var combinedBody = Expression.AndAlso(body1, body2);
        var lambda = Expression.Lambda<Func<T, bool>>(combinedBody, _parameter);

        return lambda;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        return _parameter;
    }

    private static Expression RebindParameter(Expression expr, ParameterExpression oldParameter, ParameterExpression newParameter)
    {
        return new ParameterRebinder(oldParameter, newParameter).Visit(expr);
    }

    private class ParameterRebinder : ExpressionVisitor
    {
        private readonly ParameterExpression _oldParameter;
        private readonly ParameterExpression _newParameter;

        public ParameterRebinder(ParameterExpression oldParameter, ParameterExpression newParameter)
        {
            _oldParameter = oldParameter;
            _newParameter = newParameter;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (node == _oldParameter)
                return _newParameter;

            return base.VisitParameter(node);
        }
    }
}

使用示例：

Expression<Func<int, bool>> expr1 = x => x > 5;
Expression<Func<int, bool>> expr2 = y => y < 10;

var parameter = Expression.Parameter(typeof(int), "x");
var combiner = new ExpressionCombiner(parameter);
var combinedExpr = combiner.Combine(expr1, expr2);

Console.WriteLine(combinedExpr.ToString());

输出结果：