C#表达式树 Expression.Dynamic

太过爱你忘了你带给我的痛 2023-09-27 17:29 98阅读 0赞

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作为参数传递给它。