C#：合并两个通用表达式树

using System;
using System.Linq.Expressions;

public class ExpressionMerger : ExpressionVisitor
{
    private readonly Expression _source;

    public ExpressionMerger(Expression source)
    {
        _source = source;
    }

    public Expression Merge(Expression destination)
    {
        return Visit(destination);
    }

    protected override Expression VisitLambda<T>(Expression<T> node)
    {
        // 合并两个Lambda表达式的参数
        var parameterMap = new ParameterMap(_source, node);
        var body = Visit(node.Body);

        return Expression.Lambda(body, parameterMap.GetMergedParameters());
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        // 替换目标表达式的参数为源表达式的参数
        return base.VisitParameter(_source.Parameters[node]);
    }
}

public class ParameterMap
{
    private readonly Expression _source;
    private readonly LambdaExpression _destination;
    private readonly Dictionary<ParameterExpression, ParameterExpression> _map;

    public ParameterMap(Expression source, LambdaExpression destination)
    {
        _source = source;
        _destination = destination;
        _map = new Dictionary<ParameterExpression, ParameterExpression>();
        CreateParameterMap();
    }

    private void CreateParameterMap()
    {
        for (int i = 0; i < _source.Parameters.Count; i++)
        {
            _map[_destination.Parameters[i]] = _source.Parameters[i];
        }
    }

    public ParameterExpression GetMergedParameters()
    {
        return _map[_destination.Parameters[0]];
    }
}

public class Program
{
    public static void Main()
    {
        // 创建源表达式树
        Expression<Func<int, int, int>> sourceExpression = (a, b) => a + b;

        // 创建目标表达式树
        Expression<Func<int, int, int>> destinationExpression = (x, y) => x * y;

        // 创建合并器实例
        var merger = new ExpressionMerger(sourceExpression);

        // 合并表达式树
        var mergedExpression = merger.Merge(destinationExpression);

        // 执行合并后的表达式树
        var result = Expression.Lambda<Func<int, int, int>>(mergedExpression, destinationExpression.Parameters).Compile();

        Console.WriteLine(result(2, 3)); // 输出 10 (2 * 3)
    }
}