C#表达式树 Expression.Dynamic

Expression.Dynamic 方法是 System.Linq.Expressions 命名空间中的一个方法，可以用来创建动态 LINQ 表达式树。使用 Dynamic 方法，可以在运行时构建一个 Lambda 表达式树，用来执行动态类型或未知类型的操作。

使用 Expression.Dynamic 方法可以有以下几种使用方法：

• 使用预定义的运算符：

可以使用预定义的运算符，例如加减乘除等，创建一个包含预定义操作的动态表达式树。例如：

var p1 = Expression.Parameter(typeof(int), "p1");
var p2 = Expression.Parameter(typeof(int), "p2");

var dynamicAdd = Expression.Dynamic(
    new MyBinder(),
    typeof(int),
    Expression.Add(p1, p2),
    p1,
    p2
);

在上面的例子中，我们使用了 Expression.Add 方法创建了一个加法运算表达式树，并将其作为第三个参数传递给 Expression.Dynamic 方法。此外，我们还需要传递一个 MyBinder 对象作为绑定程序，和两个操作数表达式树 p1 和 p2。

• 使用自定义操作符：

除了使用预定义的运算符外，我们还可以自定义运算符来创建动态表达式树。在这种情况下，我们需要实现 System.Runtime.CompilerServices.CallSiteBinder 类，来定义我们的自定义绑定程序。例如：

public class MyCustomBinder : CallSiteBinder
{
    private readonly string _operation;

    public MyCustomBinder(string operation)
    {
        _operation = operation;
    }

    public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel)
    {
        var p1 = parameters[0];
        var p2 = parameters[1];

        switch (_operation)
        {
            case "Multiply":
                return Expression.Multiply(p1, p2);
            case "Divide":
                return Expression.Divide(p1, p2);
            default:
                throw new ArgumentException($"Invalid operation: {_operation}");
        }
    }

    public override T BindDelegate<T>(CallSite<T> site, object[] args)
    {
        throw new NotImplementedException();
    }
}

在上面的例子中，我们创建了一个 MyCustomBinder 类来定义自定义绑定程序。在 Bind 方法中，我们根据 _operation 字段的值来判断要执行的操作，并返回相应的表达式树。

然后我们可以使用 Expression.Dynamic 方法来创建一个包含自定义操作的动态表达式树：

var p1 = Expression.Parameter(typeof(int), "p1");
var p2 = Expression.Parameter(typeof(int), "p2");

var dynamicMultiply = Expression.Dynamic(
    new MyCustomBinder("Multiply"),
    typeof(int),
    p1,
    p2
);

var dynamicDivide = Expression.Dynamic(
    new MyCustomBinder("Divide"),
    typeof(int),
    p1,
    p2
);

在上面的例子中，我们分别创建了一个乘法运算表达式树和一个除法运算表达式树，并使用 MyCustomBinder 类作为绑定程序来执行自定义的操作。

另一种使用 Expression.Dynamic 的方式是使用委托类型，并将其作为 CallSiteBinder 的参数传递。这个委托类型必须与绑定的动态调用的签名相匹配。

下面是一个简单的示例，演示如何使用委托类型和 CallSiteBinder 来调用一个动态方法：

using System;
using System.Dynamic;
using System.Linq.Expressions;

class Program
{
    static void Main(string[] args)
    {
        // 创建一个参数表达式
        var paramExpr = Expression.Parameter(typeof(int), "x");

        // 创建一个动态绑定的调用
        var binder = Binder.InvokeMember(CSharpBinderFlags.None, "Add", null, typeof(Program),
            new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });

        // 创建一个委托类型，这个委托类型接受一个 object 类型的参数，并返回一个 object 类型的值
        Func<object, object> add = Expression.Lambda<Func<object, object>>(
            Expression.Dynamic(binder, typeof(object), paramExpr), paramExpr).Compile();

        // 调用动态方法
        int x = 1;
        int y = 2;
        Console.WriteLine(add(x + y)); // 输出 3
    }
}

在上面的示例中，我们创建了一个参数表达式 paramExpr，并使用 Binder.InvokeMember 创建了一个动态绑定的调用。然后，我们使用 Expression.Dynamic 创建了一个动态调用的表达式，并将其传递给了一个委托类型，这个委托类型与绑定的动态调用的签名相匹配。最后，我们编译了这个委托类型，并使用它来调用动态方法。

需要注意的是，使用这种方式调用动态方法需要进行类型转换。在上面的示例中，我们将 int 类型的值转换为 object 类型的值，并将返回值再次转换为 int 类型的值。这种方式虽然比较麻烦，但是它提供了更大的灵活性和动态性。

当使用动态方法调用时，可以将一个委托与表达式树关联起来，然后通过该委托执行表达式树。该方法可以通过以下步骤实现：

1. 创建一个参数表达式列表，用于传递给动态方法。

2. 创建一个类型数组，指示动态方法返回的类型和参数类型。

3. 使用Expression.Call方法创建一个表达式树，该表达式树代表要调用的方法。

4. 使用Expression.Lambda方法将表达式树转换为委托。

5. 使用委托调用动态方法，将表达式树作为参数传递给它。

这种方法需要一些代码来设置，但它提供了更好的性能和更少的代码。

以下是一个使用动态方法调用的示例：

// 定义参数表达式
var parameter = Expression.Parameter(typeof(JObject), "x");

// 创建调用方法的表达式树
var methodCallExpression = Expression.Call(
    typeof(JsonConvert),
    "SerializeObject",
    Type.EmptyTypes,
    parameter);

// 将表达式树转换为委托
var lambda = Expression.Lambda<Func<JObject, string>>(
    methodCallExpression,
    parameter);

// 调用动态方法
var result = lambda.Compile()(jsonObject);

在这个示例中，我们使用了JsonConvert.SerializeObject方法，将JObject转换为JSON字符串。我们首先定义了一个参数表达式，它将作为方法调用的参数。然后我们使用Expression.Call方法创建了一个表达式树，该表达式树表示要调用的方法。接下来，我们使用Expression.Lambda方法将表达式树转换为委托，并将其编译。最后，我们使用该委托调用动态方法，并将JObject作为参数传递给它。