表达式树练习实践：C# 五类运算符的表达式树表达

• 2019 年 10 月 3 日
• 筆記

表达式树练习实践：C# 运算符

在 C# 中，算术运算符，有以下类型

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其他运算符

这些运算符根据参数的多少，可以分作一元运算符、二元运算符、三元运算符。本文将围绕这些运算符，演示如何使用表达式树进行操作。

对于一元运算符和二元运算符的 Expression 的子类型如下：

UnaryExpression; //一元运算表达式  BinaryExpression; //二元运算表达式

一，算术运算符

+ 与 Add()

正常代码

            int a;              int b;              a = 100;              b = 200;              var ab = a + b;              Console.WriteLine(ab);

使用表达式树构建

            ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");                // ab = a + b              BinaryExpression ab = Expression.Add(a, b);                // 打印 a + b 的值              MethodCallExpression method = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), ab);                Expression<Action<int, int>> lambda = Expression.Lambda<Action<int, int>>(method, a, b);              lambda.Compile()(100, 200);                Console.ReadKey();

如果想复杂一些，使用 块 来执行：

            ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");                // 别忘记了赋值              BinaryExpression aa = Expression.Assign(a, Expression.Constant(100, typeof(int)));              BinaryExpression bb = Expression.Assign(b, Expression.Constant(200, typeof(int)));                // ab = a + b              BinaryExpression ab = Expression.Add(a, b);                // 打印 a + b 的值              MethodCallExpression method = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), ab);                // 以块的形式执行代码，相当于{ }              // 不需要纠结这里，后面会有详细说明，重点是上面              var call = Expression.Block(new ParameterExpression[] { a, b }, aa, bb, method);              Expression<Action> lambda = Expression.Lambda<Action>(call);              lambda.Compile()();

上面两个示例，是使用表达式树计算结果，然后还是使用表达式树打印结果。

前者依赖外界传入参数值，赋予 a、b，后者则全部使用表达式树赋值和运算。

那么，如何通过表达式树执行运算，获取执行结果呢？

            ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");                // ab = a + b              BinaryExpression ab = Expression.Add(a, b);                Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(ab, a, b);              int result = lambda.Compile()(100, 200);                Console.WriteLine(result);              Console.ReadKey();

这些区别在于如何编写 Expression.Lambda()。

另外，使用 AddChecked() 可以检查操作溢出。

– 与 Subtract()

与加法一致，此处不再赘述，SubtractChecked() 可以检查溢出。

a - b ，结果是 100 。

            ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");                // ab = a - b              BinaryExpression ab = Expression.Subtract(a, b);                Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(ab, a, b);              int result = lambda.Compile()(200, 100);                Console.WriteLine(result);

乘除、取模

乘法

            // ab = a * b              BinaryExpression ab = Expression.Multiply(a, b);  // ab = 20000

除法

            // ab = a / b              BinaryExpression ab = Expression.Divide(a, b);  // ab = 2

取模(%)

            ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");                // ab = a % b              BinaryExpression ab = Expression.Modulo(a, b);                Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(ab, a, b);              int result = lambda.Compile()(200, 150);  // ab = 50              Console.WriteLine(result);              Console.ReadKey();

自增自减

自增自减有两种模型，一种是 x++ 或 x--，另一种是 ++x 或 --x。

他们都是属于 UnaryExpression 类型。

巧记：Post 后置， Pre 前置；Increment 是加，Decrement是减；Assign与赋值有关(后面会说到)；

x++ 与 x-- 的使用

            int a = 10;              int b = 10;              a++;              b--;              Console.WriteLine(a);              Console.WriteLine(b);

            // int a,b;              ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");                // a = 10,b = 10;              BinaryExpression setA = Expression.Assign(a, Expression.Constant(10));              BinaryExpression setB = Expression.Assign(b, Expression.Constant(10));                // a++              UnaryExpression aa = Expression.PostIncrementAssign(a);                // b--              UnaryExpression bb = Expression.PostDecrementAssign(b);                //Console.WriteLine(a);              //Console.WriteLine(b);              MethodCallExpression callA = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a);              MethodCallExpression callB = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), b);                BlockExpression block = Expression.Block(                  new ParameterExpression[] { a, b },                  setA,                  setB,                  aa,                  bb,                  callA,                  callB                  );                Expression<Action> lambda = Expression.Lambda<Action>(block);              lambda.Compile()();                Console.ReadKey();

如果想把参数从外面传入，设置 a，b

            // int a,b;              ParameterExpression a = Expression.Variable(typeof(int), "a");              ParameterExpression b = Expression.Variable(typeof(int), "b");                // a++              UnaryExpression aa = Expression.PostIncrementAssign(a);                // b--              UnaryExpression bb = Expression.PostDecrementAssign(b);                //Console.WriteLine(a);              //Console.WriteLine(b);              MethodCallExpression callA = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a);              MethodCallExpression callB = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), b);                BlockExpression block = Expression.Block(                  aa,                  bb,                  callA,                  callB                  );                Expression<Action<int, int>> lambda = Expression.Lambda<Action<int, int>>(block, a, b);              lambda.Compile()(10, 10);              Console.ReadKey();

生成的表达式树如下

.Lambda #Lambda1<System.Action`2[System.Int32,System.Int32]>(      System.Int32 $a,      System.Int32 $b) {      .Block() {          $a++;          $b--;          .Call System.Console.WriteLine($a);          .Call System.Console.WriteLine($b)      }  }

为了理解一下 Expression.Block()，可以在这里学习一下(后面会说到 Block())。

            // int a,b;              ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");              ParameterExpression c = Expression.Variable(typeof(int), "c");                BinaryExpression SetA = Expression.Assign(a, c);              BinaryExpression SetB = Expression.Assign(b, c);              // a++              UnaryExpression aa = Expression.PostIncrementAssign(a);                // b--              UnaryExpression bb = Expression.PostDecrementAssign(b);                //Console.WriteLine(a);              //Console.WriteLine(b);              MethodCallExpression callA = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a);              MethodCallExpression callB = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), b);                BlockExpression block = Expression.Block(                  new ParameterExpression[] { a, b },                  SetA,                  SetB,                  aa,                  bb,                  callA,                  callB                  );                Expression<Action<int>> lambda = Expression.Lambda<Action<int>>(block, c);              lambda.Compile()(10);                Console.ReadKey();

为什么这里要多加一个 c 呢？我们来看看生成的表达式树

.Lambda #Lambda1<System.Action`1[System.Int32]>(System.Int32 $c) {      .Block(          System.Int32 $a,          System.Int32 $b) {          $a = $c;          $b = $c;          $a++;          $b--;          .Call System.Console.WriteLine($a);          .Call System.Console.WriteLine($b)      }  }

观察一下下面代码生成的表达式树

            // int a,b;              ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");                // a++              UnaryExpression aa = Expression.PostIncrementAssign(a);                // b--              UnaryExpression bb = Expression.PostDecrementAssign(b);                //Console.WriteLine(a);              //Console.WriteLine(b);              MethodCallExpression callA = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a);              MethodCallExpression callB = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), b);                BlockExpression block = Expression.Block(                  new ParameterExpression[] { a, b },                  aa,                  bb,                  callA,                  callB                  );                Expression<Action<int, int>> lambda = Expression.Lambda<Action<int, int>>(block, a, b);              lambda.Compile()(10, 10);              Console.ReadKey();

.Lambda #Lambda1<System.Action`2[System.Int32,System.Int32]>(      System.Int32 $a,      System.Int32 $b) {      .Block(          System.Int32 $a,          System.Int32 $b) {          $a++;          $b--;          .Call System.Console.WriteLine($a);          .Call System.Console.WriteLine($b)      }  }

关于前置的自增自减，按照上面示例编写即可，但是需要注意的是， ++x 和 –x ，是“先运算后增/自减”。

二，关系运算符

==、!=、>、<、>=、<=

C# 中的关系运算符如下

== 表示相等比较，如果是值类型和 string 类型，则比较值是否相同；如果是引用类型，则比较引用的地址是否相等。

其它的关系运算符则是仅比较值类型的大小。

实例代码

            int a = 21;              int b = 10;              Console.Write("a == b：");              Console.WriteLine(a == b);                Console.Write("a < b ：");              Console.WriteLine(a < b);                  Console.Write("a > b ：");              Console.WriteLine(a > b);                // 改变 a 和 b 的值              a = 5;              b = 20;                Console.Write("a <= b：");              Console.WriteLine(a <= b);                  Console.Write("a >= b：");              Console.WriteLine(b >= a);                Console.ReadKey();

使用表达式树实现

            // int a,b;              ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");                // a = 21,b = 10;              BinaryExpression setA = Expression.Assign(a, Expression.Constant(21));              BinaryExpression setB = Expression.Assign(b, Expression.Constant(20));                // Console.Write("a == b：");              // Console.WriteLine(a == b);              MethodCallExpression call1 = Expression.Call(null,                  typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),                  Expression.Constant("a == b："));              MethodCallExpression call11 = Expression.Call(null,                  typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),                  Expression.Equal(a, b));                // Console.Write("a < b ：");              // Console.WriteLine(a < b);              MethodCallExpression call2 = Expression.Call(null,                  typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),                  Expression.Constant("a < b ："));              MethodCallExpression call22 = Expression.Call(null,                  typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),                  Expression.LessThan(a, b));                // Console.Write("a > b ：");              // Console.WriteLine(a > b);              MethodCallExpression call3 = Expression.Call(null,                  typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),                  Expression.Constant("a > b ："));              MethodCallExpression call33 = Expression.Call(null,                  typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),                  Expression.GreaterThan(a, b));                  // 改变 a 和 b 的值              // a = 5;              // b = 20;              BinaryExpression setAa = Expression.Assign(a, Expression.Constant(5));              BinaryExpression setBb = Expression.Assign(b, Expression.Constant(20));                // Console.Write("a <= b：");              // Console.WriteLine(a <= b);              MethodCallExpression call4 = Expression.Call(null,                  typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),                  Expression.Constant("a <= b："));              MethodCallExpression call44 = Expression.Call(null,                  typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),                  Expression.LessThanOrEqual(a, b));                // Console.Write("a >= b：");              // Console.WriteLine(b >= a);              MethodCallExpression call5 = Expression.Call(null,                  typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),                  Expression.Constant("a >= b："));              MethodCallExpression call55 = Expression.Call(null,                  typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),                  Expression.GreaterThanOrEqual(a, b));                BlockExpression block = Expression.Block(new ParameterExpression[] { a, b },                  setA,                  setB,                  call1,                  call11,                  call2,                  call22,                  call3,                  call33,                  setAa,                  setBb,                  call4,                  call44,                  call5,                  call55                  );                Expression<Action> lambda = Expression.Lambda<Action>(block);              lambda.Compile()();              Console.ReadKey();

生成的表达式树如下

.Lambda #Lambda1<System.Action>() {      .Block(          System.Int32 $a,          System.Int32 $b) {          $a = 21;          $b = 20;          .Call System.Console.Write("a == b：");          .Call System.Console.WriteLine($a == $b);          .Call System.Console.Write("a < b ：");          .Call System.Console.WriteLine($a < $b);          .Call System.Console.Write("a > b ：");          .Call System.Console.WriteLine($a > $b);          $a = 5;          $b = 20;          .Call System.Console.Write("a <= b：");          .Call System.Console.WriteLine($a <= $b);          .Call System.Console.Write("a >= b：");          .Call System.Console.WriteLine($a >= $b)      }  }

三，逻辑运算符

&&、||、!

逻辑运算符的运行，结果是 true 或 false。

            int a = 10;              int b = 11;                Console.Write("[a == b && a > b]：");              Console.WriteLine(a == b && a > b);                Console.Write("[a > b || a == b]：");              Console.WriteLine(a > b || a == b);                Console.Write("[!(a == b)]：");              Console.WriteLine(!(a == b));              Console.ReadKey();

使用表达式树编写

            //int a = 10;              //int b = 11;              ParameterExpression a = Expression.Parameter(typeof(int), "a");              ParameterExpression b = Expression.Parameter(typeof(int), "b");              BinaryExpression setA = Expression.Assign(a, Expression.Constant(10));              BinaryExpression setB = Expression.Assign(b, Expression.Constant(11));                //Console.Write("[a == b && a > b]：");              //Console.WriteLine(a == b && a > b);              MethodCallExpression call1 = Expression.Call(null, typeof(Console).GetMethod("Write", new Type[] { typeof(string) }), Expression.Constant("[a == b && a > b]："));                MethodCallExpression call2 = Expression.Call(                  null,                  typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),                   Expression.AndAlso(Expression.Equal(a, b), Expression.GreaterThan(a, b))                  );                //Console.Write("[a > b || a == b]：");              //Console.WriteLine(a > b || a == b);              MethodCallExpression call3 = Expression.Call(null, typeof(Console).GetMethod("Write", new Type[] { typeof(string) }), Expression.Constant("[a > b || a == b]："));              MethodCallExpression call4 = Expression.Call(                  null,                  typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),                  Expression.OrElse(Expression.Equal(a, b), Expression.GreaterThan(a, b))                  );                //Console.Write("[!(a == b)]：");              //Console.WriteLine(!(a == b));              MethodCallExpression call5 = Expression.Call(null, typeof(Console).GetMethod("Write", new Type[] { typeof(string) }), Expression.Constant("[!(a == b)]："));              MethodCallExpression call6 = Expression.Call(                  null,                  typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),                  Expression.Not(Expression.Equal(a, b))                  );              BlockExpression block = Expression.Block(                  new ParameterExpression[] { a, b },                  setA,                  setB,                  call1,                  call2,                  call3,                  call4,                  call5,                  call6                  );                Expression<Action> lambda = Expression.Lambda<Action>(block);              lambda.Compile()();              Console.ReadKey();

生成的表达式树如下

.Lambda #Lambda1<System.Action>() {      .Block(          System.Int32 $a,          System.Int32 $b) {          $a = 10;          $b = 11;          .Call System.Console.Write("[a == b && a > b]：");          .Call System.Console.WriteLine($a == $b && $a > $b);          .Call System.Console.Write("[a > b || a == b]：");          .Call System.Console.WriteLine($a == $b || $a > $b);          .Call System.Console.Write("[!(a == b)]：");          .Call System.Console.WriteLine(!($a == $b))      }  }

四，位运算符

&、|、^、~、<<、>>

限于篇幅，就写示例了。

五，赋值运算符

限于篇幅,请自行领略… …

^= ，注意有两种意思一种是位运算符的异或(ExclusiveOrAssign)，一种是算术运算符的幂运算(PowerAssign)。

六，其他运算符

表达式树里面我没有找到这些运算符的如何编写，如果你找到了，欢迎告诉我。。。