C#五类运算符使用表达式树进行操作

第C#五类运算符使用表达式树进行操作在C#中，算术运算符，有以下类型

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

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

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

UnaryExpression;//一元运算表达式

BinaryExpression;//二元运算表达式

一，算术运算符

运算符描述+把两个操作数相加-从第一个操作数中减去第二个操作数*把两个操作数相乘/分子除以分母%取模运算符，整除后的余数++自增运算符，整数值增加1--自减运算符，整数值减少1

+与Add()

正常代码

inta;

intb;

a=100;

b=200;

varab=a+b;

Console.WriteLine(ab);

使用表达式树构建

ParameterExpressiona=Expression.Parameter(typeof(int),"a");

ParameterExpressionb=Expression.Parameter(typeof(int),"b");

//ab=a+b

BinaryExpressionab=Expression.Add(a,b);

//打印a+b的值

MethodCallExpressionmethod=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),ab);

ExpressionActionint,intlambda=Expression.LambdaActionint,int(method,a,b);

lambda.Compile()(100,200);

Console.ReadKey();

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

ParameterExpressiona=Expression.Parameter(typeof(int),"a");

ParameterExpressionb=Expression.Parameter(typeof(int),"b");

//别忘记了赋值

BinaryExpressionaa=Expression.Assign(a,Expression.Constant(100,typeof(int)));

BinaryExpressionbb=Expression.Assign(b,Expression.Constant(200,typeof(int)));

//ab=a+b

BinaryExpressionab=Expression.Add(a,b);

//打印a+b的值

MethodCallExpressionmethod=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),ab);

//以块的形式执行代码，相当于{}

//不需要纠结这里，后面会有详细说明，重点是上面

varcall=Expression.Block(newParameterExpression[]{a,b},aa,bb,method);

ExpressionActionlambda=Expression.LambdaAction(call);

lambda.Compile()();

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

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

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

ParameterExpressiona=Expression.Parameter(typeof(int),"a");

ParameterExpressionb=Expression.Parameter(typeof(int),"b");

//ab=a+b

BinaryExpressionab=Expression.Add(a,b);

ExpressionFuncint,int,intlambda=Expression.LambdaFuncint,int,int(ab,a,b);

intresult=lambda.Compile()(100,200);

Console.WriteLine(result);

Console.ReadKey();

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

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

-与Subtract()

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

a-b，结果是100。

ParameterExpressiona=Expression.Parameter(typeof(int),"a");

ParameterExpressionb=Expression.Parameter(typeof(int),"b");

//ab=a-b

BinaryExpressionab=Expression.Subtract(a,b);

ExpressionFuncint,int,intlambda=Expression.LambdaFuncint,int,int(ab,a,b);

intresult=lambda.Compile()(200,100);

Console.WriteLine(result);

乘除、取模

乘法

//ab=a*b

BinaryExpressionab=Expression.Multiply(a,b);

//ab=20000

除法

//ab=a/b

BinaryExpressionab=Expression.Divide(a,b);

//ab=2

取模(%)

ParameterExpressiona=Expression.Parameter(typeof(int),"a");

ParameterExpressionb=Expression.Parameter(typeof(int),"b");

//ab=a%b

BinaryExpressionab=Expression.Modulo(a,b);

ExpressionFuncint,int,intlambda=Expression.LambdaFuncint,int,int(ab,a,b);

intresult=lambda.Compile()(200,150);

//ab=50

Console.WriteLine(result);

Console.ReadKey();

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

他们都是属于UnaryExpression类型。

算术运算符表达式树说明x++Expression.PostIncrementAssign()后置x--Expression.PostDecrementAssign()后置++xExpression.PreIncrementAssign()前置--xExpression.PreDecrementAssign()前置

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

x++与x--的使用

inta=10;

intb=10;

a++;

b--;

Console.WriteLine(a);

Console.WriteLine(b);

//inta,b;

ParameterExpressiona=Expression.Parameter(typeof(int),"a");

ParameterExpressionb=Expression.Parameter(typeof(int),"b");

//a=10,b=10;

BinaryExpressionsetA=Expression.Assign(a,Expression.Constant(10));

BinaryExpressionsetB=Expression.Assign(b,Expression.Constant(10));

//a++

UnaryExpressionaa=Expression.PostIncrementAssign(a);

//b--

UnaryExpressionbb=Expression.PostDecrementAssign(b);

//Console.WriteLine(a);

//Console.WriteLine(b);

MethodCallExpressioncallA=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),a);

MethodCallExpressioncallB=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),b);

BlockExpressionblock=Expression.Block(

newParameterExpression[]{a,b},

setA,

setB,

callA,

callB

ExpressionActionlambda=Expression.LambdaAction(block);

lambda.Compile()();

Console.ReadKey();

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

//inta,b;

ParameterExpressiona=Expression.Variable(typeof(int),"a");

ParameterExpressionb=Expression.Variable(typeof(int),"b");

//a++

UnaryExpressionaa=Expression.PostIncrementAssign(a);

//b--

UnaryExpressionbb=Expression.PostDecrementAssign(b);

//Console.WriteLine(a);

//Console.WriteLine(b);

MethodCallExpressioncallA=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),a);

MethodCallExpressioncallB=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),b);

BlockExpressionblock=Expression.Block(

callA,

callB

ExpressionActionint,intlambda=Expression.LambdaActionint,int(block,a,b);

lambda.Compile()(10,10);

Console.ReadKey();

生成的表达式树如下

.Lambda#Lambda1System.Action`2[System.Int32,System.Int32](

System.Int32$a,

System.Int32$b){

.Block(){

$a++;

$b--;

.CallSystem.Console.WriteLine($a);

.CallSystem.Console.WriteLine($b)

}

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

//inta,b;

ParameterExpressiona=Expression.Parameter(typeof(int),"a");

ParameterExpressionb=Expression.Parameter(typeof(int),"b");

ParameterExpressionc=Expression.Variable(typeof(int),"c");

BinaryExpressionSetA=Expression.Assign(a,c);

BinaryExpressionSetB=Expression.Assign(b,c);

//a++

UnaryExpressionaa=Expression.PostIncrementAssign(a);

//b--

UnaryExpressionbb=Expression.PostDecrementAssign(b);

//Console.WriteLine(a);

//Console.WriteLine(b);

MethodCallExpressioncallA=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),a);

MethodCallExpressioncallB=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),b);

BlockExpressionblock=Expression.Block(

newParameterExpression[]{a,b},

SetA,

SetB,

callA,

callB

ExpressionActionintlambda=Expression.LambdaActionint(block,c);

lambda.Compile()(10);

Console.ReadKey();

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

.Lambda#Lambda1System.Action`1[System.Int32](System.Int32$c){

.Block(

System.Int32$a,

System.Int32$b){

$a=$c;

$b=$c;

$a++;

$b--;

.CallSystem.Console.WriteLine($a);

.CallSystem.Console.WriteLine($b)

}

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

//inta,b;

ParameterExpressiona=Expression.Parameter(typeof(int),"a");

ParameterExpressionb=Expression.Parameter(typeof(int),"b");

//a++

UnaryExpressionaa=Expression.PostIncrementAssign(a);

//b--

UnaryExpressionbb=Expression.PostDecrementAssign(b);

//Console.WriteLine(a);

//Console.WriteLine(b);

MethodCallExpressioncallA=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),a);

MethodCallExpressioncallB=Expression.Call(null,typeof(Console).GetMethod("WriteLine",newType[]{typeof(int)}),b);

BlockExpressionblock=Expression.Block(

newParameterExpression[]{a,b},

callA,

callB

ExpressionActionint,intlambda=E