表达式树（Expression）的执行、解释与创建

少林寺扫地的

前言：在这里不进行概念性描述，能看到这篇文章说明你已经知道如何使用表达式树
执行

这里需要说明下表达式树是表示代码的数据结构，并不是经过编译且可执行的代码，如果想要执行由表达式树表示的 .NET 代码，必须将其转换为可执行的 IL 指令。这时候我们需要调用编译函数创建委托（Delegate），再执行。
执行编译后的委托通常看到三种方式：func(入参)、func.Invoke(入参)、func.DynamicInvoke(入参)
前两种用于在确认委托类型是可直接调用，DynamicInvoke一般在不确定委托的具体类型时调用

1. {
2.      //  
3.      //  定义Expression
4.      //  @return  int
5.      //  @params  int(a),int(b)
6.      //
7.      Expression<Func<int, int, int>> expression = (a, b) => a + b;
8.      //编译创建委托
9.      Func<int, int, int> func = expression.Compile();
10.      //入参执行
11.      Console.WriteLine(func(1, 2));
12.      Console.WriteLine(func.Invoke(1, 2));
13.      Console.WriteLine(func.DynamicInvoke(1, 2));
14. }
17. {
18.      //  
19.      //  创建Expression
20.      //  @return  int
21.      //  @params  UserInfo(user)
22.      //
23.      //入参表达式
24.      var param = Expression.Parameter(typeof(UserInfo), "user");
25.      //参数属性访问器表达式
26.      var member = Expression.MakeMemberAccess(param, typeof(UserInfo).GetMember("Age").FirstOrDefault()!);
27.      //常量表达式
28.      var constant = Expression.Constant(999);
29.      //二进制计算表达式
30.      var body = Expression.Add(member, constant);
31.      //Lambda表达式
32.      var lambda = Expression.Lambda(body, param);
33.      Console.WriteLine(lambda.Compile().DynamicInvoke(new UserInfo() { Age = 1 }));
34.      //Console.WriteLine(((Func<UserInfo, int>)lambda.Compile()).DynamicInvoke(new UserInfo() { Age = 1 }));
35. }

复制代码

注意Lambda 表达式将对表达式中引用的任何局部变量创建闭包，必须保证作为委托的一部分的任何变量在调用 Compile 的位置处和执行结果委托时可用，例如以下这种情况将会抛出异常

1. public class Resource : IDisposable
2. {
3.      private bool _isDisposed = false;
4.      public int Argument
5.      {
6.          get
7.          {
8.              if (!_isDisposed)
9.                  return 5;
10.              else throw new ObjectDisposedException("资源已被释放");
11.          }
12.      }
14.      public void Dispose()
15.      {
16.          _isDisposed = true;
17.      }
18. }
20. {
21.      var constant = new Resource();
22.      Expression<Func<int, int>> expression = (b) => constant.Argument + b;
23.      var func = expression.Compile();
24.      try
25.      {
26.          //  释放后入参执行
27.          constant.Dispose();
28.          Console.WriteLine(func(1));
29.      }
30.      catch (Exception ex)
31.      {
32.          Console.WriteLine(ex);
33.      // 异常
34.      //System.ObjectDisposedException: Cannot access a disposed object.Object     name: '资源已被释放'
35.      }
36. }

复制代码

 
解释

解析表达式树能够让我们更好的理解和创建复杂的代码结构树，下面是一个简单的demo我直接从官网复制的。他解释了这个表达式的类型、参数、返回类型、以及表达式体的左右结构

1.   Expression<Func<int, int, int>> addition = (a, b) => a + b;
2.   Console.WriteLine($"This expression is a {addition.NodeType} expression type");
3.   Console.WriteLine($"The name of the lambda is {((addition.Name == null) ? "<null>" : addition.Name)}");
4.   Console.WriteLine($"The return type is {addition.ReturnType.ToString()}");
5.   Console.WriteLine($"The expression has {addition.Parameters.Count} arguments. They are:");
6.   foreach (var argumentExpression in addition.Parameters)
7.   {
8.       Console.WriteLine($"\tParameter Type: {argumentExpression.Type.ToString()}, Name: {argumentExpression.Name}");
9.   }
10.   var additionBody = (BinaryExpression)addition.Body;
11.   Console.WriteLine($"The body is a {additionBody.NodeType} expression");
12.   Console.WriteLine($"The left side is a {additionBody.Left.NodeType} expression");
13.   var left = (ParameterExpression)additionBody.Left;
14.   Console.WriteLine($"\tParameter Type: {left.Type.ToString()}, Name: {left.Name}");
15.   Console.WriteLine($"The right side is a {additionBody.Right.NodeType} expression");
16.   var right = (ParameterExpression)additionBody.Right;
17.   Console.WriteLine($"\tParameter Type: {right.Type.ToString()}, Name: {right.Name}");

复制代码

输出：

 
如上所示是一个很简单的表达式树，依次解析表达式树的本身信息->表达式结构体->结构体的左右表达式，在表达式中每一个参数变量都是一个表达式结构。如果想要解析更复杂的表达式，我们需要递归从外层依次从左往右剥离这个表达式树，在ExpressionType这个枚举中我们能看到所有的表达式类型（80余种），笔者自己在代码种匹配了27种表达式类型的解析。下面给出一些案例和完成的解析代码：
完整解析类：

1. // Base Visitor class:
2. public abstract class Visitor
3. {
4.     private readonly Expression node;
5.     protected Visitor(Expression node) => this.node = node;
6.     public abstract void Visit(string prefix);
7.     public ExpressionType NodeType => node.NodeType;
9.     protected void ForegroundColor(ConsoleColor consoleColor, string key, bool isLine)
10.     {
11.         Console.ForegroundColor = consoleColor;
12.         if (isLine)
13.         {
14.             Console.WriteLine(key);
15.         }
16.         else
17.         {
18.             Console.Write(key);
19.         }
20.         Console.ResetColor();
21.     }
23.     //27
24.     public static Visitor CreateFromExpression(Expression node) =>
25.      node.NodeType switch
26.      {
27.          ExpressionType.Lambda => new LambdaVisitor((LambdaExpression)node),
29.          ExpressionType.Add => new BinaryVisitor((BinaryExpression)node),
30.          ExpressionType.AddChecked => new BinaryVisitor((BinaryExpression)node),
31.          ExpressionType.AddAssign => new BinaryVisitor((BinaryExpression)node),
32.          ExpressionType.AddAssignChecked => new BinaryVisitor((BinaryExpression)node),
33.       
34.          ExpressionType.Subtract => new BinaryVisitor((BinaryExpression)node),
35.          ExpressionType.SubtractChecked => new BinaryVisitor((BinaryExpression)node),
36.          ExpressionType.SubtractAssign => new BinaryVisitor((BinaryExpression)node),
37.          ExpressionType.SubtractAssignChecked => new BinaryVisitor((BinaryExpression)node),
39.          ExpressionType.Multiply => new BinaryVisitor((BinaryExpression)node),
40.          ExpressionType.MultiplyChecked => new BinaryVisitor((BinaryExpression)node),
41.          ExpressionType.MultiplyAssign => new BinaryVisitor((BinaryExpression)node),
42.          ExpressionType.MultiplyAssignChecked => new BinaryVisitor((BinaryExpression)node),
44.          ExpressionType.Divide => new BinaryVisitor((BinaryExpression)node),
45.          ExpressionType.DivideAssign => new BinaryVisitor((BinaryExpression)node),
47.          ExpressionType.Modulo => new BinaryVisitor((BinaryExpression)node),
48.          ExpressionType.ModuloAssign => new BinaryVisitor((BinaryExpression)node),
50.          ExpressionType.GreaterThan => new BinaryVisitor((BinaryExpression)node),
51.          ExpressionType.OrElse => new BinaryVisitor((BinaryExpression)node),
53.          ExpressionType.Constant => new ConstantVisitor((ConstantExpression)node),
54.   
56.          ExpressionType.Parameter => new ParameterVisitor((ParameterExpression)node),
57.          ExpressionType.Equal => new BinaryVisitor((BinaryExpression)node),
59.          ExpressionType.Conditional => new ConditionalVisitor((ConditionalExpression)node),
60.          ExpressionType.Call => new MethodCallVisitor((MethodCallExpression)node),
62.          ExpressionType.MemberAccess => new MemberAccessVisitor((MemberExpression)node),
63.          ExpressionType.Convert => new ConvertVisitor((UnaryExpression)node),
65.          ExpressionType.MemberInit => new NewVisitor((MemberInitExpression)node),
66.       
67.          _ => new BinaryVisitor((BinaryExpression)node),
68.      };
69. }
72. //  New Visitor: 类型初始化
73. public class NewVisitor : Visitor {
75.     private readonly MemberInitExpression node;
76.     public NewVisitor(MemberInitExpression node) : base(node) => this.node = node;
78.     public override void Visit(string prefix)
79.     {
80.         Console.Write($"{prefix}Expression Node Type：");
81.         ForegroundColor(ConsoleColor.DarkBlue, $"{NodeType}", false);
83.         Console.Write($"    =>  ");
84.         ForegroundColor(ConsoleColor.Green, $"{node}", true);
86.         Console.Write($"{prefix}New Type：");
87.         ForegroundColor(ConsoleColor.DarkGray, $"{node.NewExpression}", true);
89.         Console.WriteLine($"{prefix}Members：");
90.         foreach (MemberAssignment item in node.Bindings)
91.         {
92.             Console.Write($"{prefix}\t");
93.             ForegroundColor(ConsoleColor.DarkGray, $"{item.Member}", true);
94.             var member = CreateFromExpression(item.Expression);
95.             member.Visit(prefix + "\t\t");
96.         }
97.     }
98. }
101. //  Convert Visitor: 一元运算符
102. public class ConvertVisitor : Visitor
103. {
104.     private readonly UnaryExpression node;
105.     public ConvertVisitor(UnaryExpression node) : base(node) => this.node = node;
107.     public override void Visit(string prefix)
108.     {
109.         Console.Write($"{prefix}Expression Node Type：");
110.         ForegroundColor(ConsoleColor.DarkBlue, $"{NodeType}", false);
112.         Console.Write($"    =>  ");
113.         ForegroundColor(ConsoleColor.Green, $"{node}", true);
115.         Console.Write($"{prefix}To Type：");
116.         ForegroundColor(ConsoleColor.DarkGray, $"{node.Type}", true);
118.         Console.Write($"{prefix}To Type Body：");
119.         ForegroundColor(ConsoleColor.DarkGray, $"{node.Operand}", true);
121.         var left = CreateFromExpression(node.Operand);
122.         Console.WriteLine($"{prefix}Analysis Body：");
123.         left.Visit(prefix + "\t");
124.     }
125. }
128. //  MemberAccess Visitor: 属性访问器
129. public class MemberAccessVisitor : Visitor
130. {
131.     private readonly MemberExpression node;
132.     public MemberAccessVisitor(MemberExpression node) : base(node) => this.node = node;
134.     public override void Visit(string prefix)
135.     {
136.         Console.Write($"{prefix}Expression Node Type：");
137.         ForegroundColor(ConsoleColor.DarkBlue, $"{NodeType}", false);
139.         Console.Write($"    =>  ");
140.         ForegroundColor(ConsoleColor.Green, $"{node}", true);
143.         Console.Write($"{prefix}In：");
144.         ForegroundColor(ConsoleColor.DarkGray, $"{node.Member.DeclaringType}", true);
146.         string type = node.Member.MemberType switch
147.         {
149.             MemberTypes.Event => ((EventInfo)node.Member).EventHandlerType.Name,
150.             MemberTypes.Field => ((FieldInfo)node.Member).FieldType.Name,
151.             MemberTypes.Method => ((MethodInfo)node.Member).ReturnType.Name,
152.             MemberTypes.Property => ((PropertyInfo)node.Member).PropertyType.Name,
153.             _ => throw new ArgumentException
154.                  (
155.                   "Input MemberInfo must be if type EventInfo, FieldInfo, MethodInfo, or PropertyInfo"
156.                  )
157.         };
158.         Console.Write($"{prefix}Type：");
159.         ForegroundColor(ConsoleColor.DarkGray, $"{type}", true);
161.         Console.Write($"{prefix}Name：");
162.         ForegroundColor(ConsoleColor.DarkGray, $"{node.Member.Name}", true);
163.     }
164. }
168. // Lambda Visitor: Lambda表达式
169. public class LambdaVisitor : Visitor
170. {
171.     private readonly LambdaExpression node;
172.     public LambdaVisitor(LambdaExpression node) : base(node) => this.node = node;
173.     public override void Visit(string prefix)
174.     {
175.         Console.Write($"{prefix}Expression Node Type：");
176.         ForegroundColor(ConsoleColor.DarkBlue, $"{NodeType}", false);
178.         Console.Write($"    =>  ");
179.         ForegroundColor(ConsoleColor.Green, $"{node}", true);
181.         Console.Write($"{prefix}Name：");
182.         ForegroundColor(ConsoleColor.DarkGray, $"{((node.Name == null) ? "<null>" : node.Name)}", true);
184.         Console.Write($"{prefix}ReturnType：");
185.         ForegroundColor(ConsoleColor.DarkGray, $"{node.ReturnType}", true);
187.         Console.Write($"{prefix}Parameters：");
188.         ForegroundColor(ConsoleColor.DarkGray, $"{node.Parameters.Count}", true);
190.         for (int i = 0; i < node.Parameters.Count; i++)
191.         {
192.             var argumentVisitor = CreateFromExpression(node.Parameters[i]);
193.             argumentVisitor.Visit(prefix + "\t");
194.         }
196.         Console.WriteLine($"{prefix}Analysis Body：");
197.         var bodyVisitor = CreateFromExpression(node.Body);
198.         bodyVisitor.Visit(prefix + "\t");
199.     }
200. }
202. // Binary Expression Visitor:二进制运算符
203. public class BinaryVisitor : Visitor
204. {
205.     private readonly BinaryExpression node;
206.     public BinaryVisitor(BinaryExpression node) : base(node) => this.node = node;
208.     public override void Visit(string prefix)
209.     {
210.         Console.Write($"{prefix}Expression Node Type：");
211.         ForegroundColor(ConsoleColor.DarkBlue, $"{NodeType}", false);
213.         Console.Write($"    =>  ");
214.         ForegroundColor(ConsoleColor.Green, $"{node}", true);
217.         var left = CreateFromExpression(node.Left);
218.         Console.WriteLine($"{prefix}Left Analysis：");
219.         left.Visit(prefix + "\t");
220.         var right = CreateFromExpression(node.Right);
221.         Console.WriteLine($"{prefix}Right Analysis：");
222.         right.Visit(prefix + "\t");
223.     }
224. }
227. // Parameter visitor: 参数类型
228. public class ParameterVisitor : Visitor
229. {
230.     private readonly ParameterExpression node;
231.     public ParameterVisitor(ParameterExpression node) : base(node)
232.     {
233.         this.node = node;
234.     }
236.     public override void Visit(string prefix)
237.     {
238.         Console.Write($"{prefix}Name：");
239.         ForegroundColor(ConsoleColor.DarkGray, $"{node.Name}", false);
241.         Console.Write($"    Type：");
242.         ForegroundColor(ConsoleColor.DarkGray, $"{node.Type}", false);
244.         Console.Write($"    ByRef：");
245.         ForegroundColor(ConsoleColor.DarkGray, $"{node.IsByRef}", true);
246.     }
247. }
250. // Constant visitor: 常数类型
251. public class ConstantVisitor : Visitor
252. {
253.     private readonly ConstantExpression node;
254.     public ConstantVisitor(ConstantExpression node) : base(node) => this.node = node;
255.     public override void Visit(string prefix)
256.     {
257.         Console.Write($"{prefix}Expression Node Type：");
258.         ForegroundColor(ConsoleColor.DarkBlue, $"{NodeType}", false);
260.         Console.Write($"    =>  ");
261.         ForegroundColor(ConsoleColor.Green, $"{node}", true);
263.         Console.Write($"{prefix}Type：");
264.         ForegroundColor(ConsoleColor.DarkGray, $"{node.Type}", true);
266.         Console.Write($"{prefix}Value：");
267.         ForegroundColor(ConsoleColor.DarkGray, $"{node.Value}", true);
268.     }
269. }
271. // Conditional visitor: 条件处理
272. public class ConditionalVisitor : Visitor
273. {
274.     private readonly ConditionalExpression node;
275.     public ConditionalVisitor(ConditionalExpression node) : base(node)
276.     {
277.         this.node = node;
278.     }
279.     public override void Visit(string prefix)
280.     {
281.         Console.Write($"{prefix}Expression Node Type：");
282.         ForegroundColor(ConsoleColor.DarkBlue, $"{NodeType}", false);
284.         Console.Write($"    =>  ");
285.         ForegroundColor(ConsoleColor.Green, $"{node}", true);
287.         var testVisitor = Visitor.CreateFromExpression(node.Test);
288.         Console.WriteLine($"{prefix}Analysis Test:");
289.         testVisitor.Visit(prefix + "\t");
290.         var trueVisitor = Visitor.CreateFromExpression(node.IfTrue);
291.         Console.WriteLine($"{prefix}Analysis IfTrue:");
292.         trueVisitor.Visit(prefix + "\t");
293.         var falseVisitor = Visitor.CreateFromExpression(node.IfFalse);
294.         Console.WriteLine($"{prefix}Analysis IfFalse:");
295.         falseVisitor.Visit(prefix + "\t");
296.     }
297. }
299. // MethodCall visitor: 方法调用
300. public class MethodCallVisitor : Visitor
301. {
302.     private readonly MethodCallExpression node;
303.     public MethodCallVisitor(MethodCallExpression node) : base(node)
304.     {
305.         this.node = node;
306.     }
308.     public override void Visit(string prefix)
309.     {
310.         Console.Write($"{prefix}Expression Node Type：");
311.         ForegroundColor(ConsoleColor.DarkBlue, $"{NodeType}", false);
313.         Console.Write($"    =>  ");
314.         ForegroundColor(ConsoleColor.Green, $"{node}", true);
316.         Console.Write($"{prefix}Static or Receiver：");
317.         if (node.Object == null)
318.         {
319.             ForegroundColor(ConsoleColor.DarkGray, $"static", true);
320.         }
321.         else
322.         {
323.             ForegroundColor(ConsoleColor.DarkGray, $"receiver (this)", true);
324.             Console.WriteLine($"{prefix}Method Analysis：");
325.             var receiverVisitor = Visitor.CreateFromExpression(node.Object);
326.             receiverVisitor.Visit(prefix + "\t");
327.         }
329.         var methodInfo = node.Method;
330.         Console.Write($"{prefix}Method Name：");
331.         ForegroundColor(ConsoleColor.DarkGray, $"{methodInfo.DeclaringType}.{methodInfo.Name}", true);
333.         Console.WriteLine($"{prefix}Arguments：");
334.         foreach (var arg in node.Arguments)
335.         {
336.             var argVisitor = Visitor.CreateFromExpression(arg);
337.             argVisitor.Visit(prefix + "\t");
338.         }
339.     }
341. }

复制代码

View Codedemo1：（demo1的出输出太长无法贴图，建议读者自己尝试）

1.   public class TestMonths
2.   {
3.       public  int Conver32(int a)
4.       {
5.           return Convert.ToInt32(a);
6.       }
7.   }
9.    TestMonths testMonths = new TestMonths();
10.    var gg = 99;
11.    Expression<Func<UserInfo, int, int, double>> exception = (user, a, b) => user.Age + (a / b) * a - b + a - (b + b) + (a % b) + (a > b ? a : b) / user.Level * gg + testMonths.Conver32(user.Level);
12.    LambdaVisitor visitor = new LambdaVisitor(exception);
13.    visitor.Visit("解析二进制运算:");
14.    Console.WriteLine("\t");

复制代码

demo2：

1. Expression<Func<UserInfo, UserInfoModel>> lambda = (user) => new UserInfoModel
2. {
3.      Age = user.Age,
4.      Level = EF.Functions.DataLength(user.Name) ?? 0,
5.      Name = user.Name
6. };
7. LambdaVisitor visitor3 = new LambdaVisitor(lambda);
8. visitor3.Visit("解析查询表达式:");

复制代码

 
创建

只有了解了他的构造，我们才懂得如何创建，下面给出两个例子分别是最常用的属性访问器和条件判断表达式

1.   //属性访问器
2.   {
3.       //需要构建的表达式
4.       Expression<Func<UserInfo, int>> left = (user) => user.Age;
6.       //1.创建访问对象表达式  =>(user)
7.       var param = Expression.Parameter(typeof(UserInfo), "user");
9.       //
10.       //2.创建访问属性表达式 =>(user.Age)
11.       //      @expression 我们需要访问成员的归属对象
12.       //      @member     成员访问器
13.       var member = Expression.MakeMemberAccess(param, typeof(UserInfo).GetMember("Age").FirstOrDefault()!);
15.       //3.创建Lambda表达式
16.       var lambda = Expression.Lambda(member, param);
18.       //测试编译输出 18
19.       Console.WriteLine(lambda.Compile().DynamicInvoke(new UserInfo { Age = 18 }));
21.   }
23.   //条件判断表达式
24.   {
25.       //需要构建的表达式
26.       Expression<Func<UserInfo, bool>> left = (user) => user.Age > 9;
28.       //1.创建访问对象表达式   =>(user)
29.       var param = Expression.Parameter(typeof(UserInfo), "user");
31.       //
32.       //2.创建访问属性表达式   =>(user.Age)
33.       //      @expression 我们需要访问成员的归属对象
34.       //      @member     成员访问器
35.       var member = Expression.MakeMemberAccess(param, typeof(UserInfo).GetMember("Age").FirstOrDefault()!);
37.       //
38.       //3.创建常量表达式    =>(9)
39.       var constant = Expression.Constant(9);
41.       //
42.       //4.创建条件判断表达式    =>(>)
43.       var greaterThan = Expression.GreaterThan(member, constant);
45.       //5.创建Lambda表达式
46.       var lambda = Expression.Lambda(greaterThan, param);
48.       //测试编译输出 True
49.       Console.WriteLine(lambda.Compile().DynamicInvoke(new UserInfo { Age = 18 }));
50.   }

复制代码

如上所述，通过解析表达式反推创建表达式树是一种不错的方法，还有更加复杂的创建方式不再介绍，笔者只提供思路。
在这里推荐一个不错的库可以直接将表达式树解释成C#或VB代码ExpressionTreeToString
只要你掌握了规则，我相信这对你来说不是难事。

来源:https://www.cnblogs.com/largeprob/p/18026782
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！