C# 表达式树 Expression

表达式树是定义代码的数据结构。它们基于编译器用于分析代码和生成已编译输出的相同结构。

几种常见的表达式

BinaryExpression 包含二元运算符的表达式

                 BinaryExpression binaryExpression = Expression.MakeBinary(ExpressionType.Add,Expression.Constant(),Expression.Constant());

                 Console.WriteLine(binaryExpression.ToString());//(1+2) 不进行溢出检查

                 binaryExpression = Expression.MakeBinary(ExpressionType.AddChecked, Expression.Constant(), Expression.Constant());

                 Console.WriteLine(binaryExpression.ToString());//(3+4) 进行溢出检查

                 binaryExpression = Expression.MakeBinary(ExpressionType.Subtract, Expression.Constant(), Expression.Constant());

                 Console.WriteLine(binaryExpression.ToString());//(5-6) 不进行溢出检查

                 binaryExpression = Expression.MakeBinary(ExpressionType.SubtractChecked, Expression.Constant(), Expression.Constant());

                 Console.WriteLine(binaryExpression.ToString());//(7-8) 进行溢出检查

                 binaryExpression = Expression.MakeBinary(ExpressionType.Multiply, Expression.Constant(), Expression.Constant());

                 Console.WriteLine(binaryExpression.ToString());//(9*10) 不进行溢出检查

                 binaryExpression = Expression.MakeBinary(ExpressionType.MultiplyChecked, Expression.Constant(), Expression.Constant());

                 Console.WriteLine(binaryExpression.ToString());//(11*12) 进行溢出检查

                 binaryExpression = Expression.MakeBinary(ExpressionType.Divide, Expression.Constant(), Expression.Constant());

                 Console.WriteLine(binaryExpression.ToString());//(13/14)

                 binaryExpression = Expression.MakeBinary(ExpressionType.Modulo, Expression.Constant(), Expression.Constant());

                 Console.WriteLine(binaryExpression.ToString());//(15%16)

BlockExpression 包含一个表达式序列的块，表达式中可定义变量

                 BlockExpression blockExpr = Expression.Block(

                      Expression.Call(null, typeof(Console).GetMethod("Write", new Type[] { typeof(String) }), Expression.Constant("Hello ")),

                      Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(String) }), Expression.Constant("World!")),

                      Expression.Constant()

                 );

                 var result = Expression.Lambda<Func<int>>(blockExpr).Compile()();

                 Console.WriteLine("**************************");

                 foreach (var expr in blockExpr.Expressions)

                     Console.WriteLine(expr.ToString());

                 Console.WriteLine("**************************");

                 Console.WriteLine(result);

程序执行结果

ConditionalExpression 具有条件运算符的表达式

Expression conditionExpr = Expression.Condition(Expression.Constant(num > 10),Expression.Constant("num is greater than 10"),Expression.Constant("num is smaller than 10"));

ConstantExpression 具有常数值的表达式

 Expression.Constant(5.5);

 Expression.Constant("Hello World！");

DefaultExpression 类型或空表达式的默认值

                 Expression defaultExpr = Expression.Default(typeof(byte));

                 // Print out the expression.

                 Console.WriteLine(defaultExpr.ToString());//  等价于 default(byte)

                 // The following statement first creates an expression tree,

                 // then compiles it, and then executes it.

                 Console.WriteLine(Expression.Lambda<Func<byte>>(defaultExpr).Compile()());//

ParameterExpression 命名的参数表达式

ParameterExpression param = Expression.Parameter(typeof(int));

IndexExpression 编制属性或数组的索引

                 ParameterExpression arrayExpr = Expression.Parameter(typeof(int[]), "Array");

                 ParameterExpression indexExpr = Expression.Parameter(typeof(int), "Index");

                 ParameterExpression valueExpr = Expression.Parameter(typeof(int), "Value");

                 Expression arrayAccessExpr = Expression.ArrayAccess(

                     arrayExpr,

                     indexExpr

                 );//Array[Index]

InvocationExpression 将委托或 lambda 表达式应用于参数表达式列表的表达式

                 Expression<Func<int, int, bool>> largeSumTest =(num1, num2) => (num1 + num2) > ;

                 InvocationExpression invocationExpression =Expression.Invoke(largeSumTest,Expression.Constant(),Expression.Constant());

                 Console.WriteLine(invocationExpression.ToString());//Invoke((num1, num2) => ((num1 + num2) > 1000), 539, 281)

LambdaExpression 描述一个 lambda 表达式。这将捕获与 .NET 方法体类似的代码块

                 ParameterExpression paramExpr = Expression.Parameter(typeof(int), "arg");

                 LambdaExpression lambdaExpr = Expression.Lambda(Expression.Add(paramExpr,Expression.Constant()),new List<ParameterExpression>() { paramExpr });

                 Console.WriteLine(lambdaExpr);// arg => (arg +1)

ElementInit 表示 IEnumerable 集合的单个元素的初始值设定项

ListInitExpression 表示包含集合初始值设定项的构造函数调用

NewExpression 构造函数调用

                 string tree1 = "maple";

                 string tree2 = "oak";

                 MethodInfo addMethod = typeof(Dictionary<int, string>).GetMethod("Add");

                 // Create two ElementInit objects that represent the

                 // two key-value pairs to add to the Dictionary.

                 ElementInit elementInit1 =Expression.ElementInit(addMethod,Expression.Constant(tree1.Length),Expression.Constant(tree1));

                 ElementInit elementInit2 =Expression.ElementInit(addMethod,Expression.Constant(tree2.Length),Expression.Constant(tree2));

                 // Create a NewExpression that represents constructing

                 // a new instance of Dictionary<int, string>.

                 NewExpression newDictionaryExpression = Expression.New(typeof(Dictionary<int, string>));//等价 new Dictionary<int, string>();

                 // Create a ListInitExpression that represents initializing

                 // a new Dictionary<> instance with two key-value pairs.

                 ListInitExpression listInitExpression = Expression.ListInit(newDictionaryExpression, elementInit1, elementInit2);//等价 var dic= new Dictionary<int, string>{}; dic.Add(5,"maple");dic.Add(3,"oak");

                 Console.WriteLine(listInitExpression.ToString());

LoopExpression 无限循环。可以使用“break”退出它

LabelTarget 表示 GotoExpression 的目标

                 ParameterExpression value = Expression.Parameter(typeof(int), "value");

                 ParameterExpression result = Expression.Parameter(typeof(int), "result");

                 LabelTarget label = Expression.Label(typeof(int));

                 BlockExpression block = Expression.Block(

                     new[] { result },

                     Expression.Assign(result, Expression.Constant()),

                         Expression.Loop(

                            Expression.IfThenElse(

                                Expression.GreaterThan(value, Expression.Constant()),

                                Expression.MultiplyAssign(result,

                                    Expression.PostDecrementAssign(value)),

                                Expression.Break(label, result)

                            ),

                        label

                     )

                 );

                 //var s =value=>

                 //{

                 //    var result = 1;

                 //    for (int i = value; i >1; i--)

                 //    {

                 //        result *= i;

                 //    }

                 //    return result;

                 //};

MemberAssignment 针对对象的字段或属性的赋值运算

MemberBinding 提供一种基类，该基类派生表示绑定的类，这些绑定用于初始化新创建对象的成员

MemberExpression 访问字段或属性

MemberInitExpression 调用构造函数并初始化新对象的一个或多个成员

MemberListBinding 初始化新创建对象的集合成员的元素

MemberMemberBinding 初始化新创建对象的成员的成员

     public class BaseEntity

     {

         /// <summary>

         /// 创建人账号

         /// </summary>

         [DataMember]

         [Display(Name = "创建人账号")]

         [Column]

         public string CreateMan { get; set; }

         /// <summary>

         /// 创建时间

         /// </summary>

         [DataMember]

         [Display(Name = "创建时间")]

         public DateTime CreateDateTime { get; set; }

         /// <summary>

         /// 异动人账号

         /// </summary>

         [DataMember]

         [Display(Name = "异动人账号")]

         public string TrMan { get; set; }

         /// <summary>

         /// 异动时间

         /// </summary>

         [DataMember]

         [Display(Name = "异动时间")]

         public DateTime TrDateTime { get; set; }

         /// <summary>

         /// 时间戳

         /// </summary>

         [DataMember]

         [Display(Name = "时间戳")]

         public DateTime? TrVersion { get; set; }

     }

                 BaseEntity entity = new BaseEntity();

                 NewExpression newExp = Expression.New(typeof(BaseEntity));

                 MemberInfo createMan = typeof(BaseEntity).GetMember("CreateMan")[];

                 MemberInfo trMan = typeof(BaseEntity).GetMember("TrMan")[];

                 MemberBinding createManMemberBinding = Expression.Bind(createMan, Expression.Constant("horse"));

                 MemberBinding trManMemberBinding = Expression.Bind(trMan, Expression.Constant("admin"));

                 MemberInitExpression memberInitExpression = Expression.MemberInit(newExp, createManMemberBinding, trManMemberBinding);

                 Console.WriteLine(memberInitExpression.ToString());

NewArrayExpression 创建新数组并可能初始化该新数组的元素

                 List<Expression> trees =new List<Expression>()

                 {

                     Expression.Constant("oak"),

                     Expression.Constant("fir"),

                     Expression.Constant("spruce"),

                     Expression.Constant("alder")

                 };

                 NewArrayExpression newArrayExpression =Expression.NewArrayInit(typeof(string), trees);

                 // new [] {"oak", "fir", "spruce", "alder"}

                 Console.WriteLine(newArrayExpression.ToString());

SwitchCase SwitchExpression 的一个事例

SwitchExpression 一个控制表达式，该表达式通过将控制传递到 SwitchCase 来处理多重选择

                 ConstantExpression switchValue = Expression.Constant();

                 SwitchExpression switchExpr =Expression.Switch(switchValue,new SwitchCase[] {

                     Expression.SwitchCase(Expression.Call(null,

                     typeof(Console).GetMethod("WriteLine", new Type[] { typeof(String) }),

                     Expression.Constant("First")),Expression.Constant()),

                     Expression.SwitchCase(Expression.Call(null,

                     typeof(Console).GetMethod("WriteLine", new Type[] { typeof(String) }),

                     Expression.Constant("Second")),Expression.Constant())});

                 Expression.Lambda<Action>(switchExpr).Compile()();

TryExpression try/catch/finally/fault 块

CatchBlock try 块中的 catch 语句

                     TryExpression tryCatchExpr =Expression.TryCatch(

                     Expression.Block(

                         Expression.Throw(Expression.Constant(new DivideByZeroException())),

                         Expression.Constant("Try block")

                     ),

                     Expression.Catch(

                         typeof(DivideByZeroException),

                         Expression.Constant("Catch block")

                 ));

UnaryExpression 包含一元运算符的表达式

UnaryExpression typeAsExpression =Expression.TypeAs(Expression.Constant(34, typeof(int)),typeof(int?));//等价 34 as int?;

微软文档地址：

System.Linq.Expressions：https://docs.microsoft.com/zh-cn/dotnet/api/system.linq.expressions?view=netframework-4.8

ExpressionType：https://docs.microsoft.com/zh-cn/dotnet/api/system.linq.expressions.expressiontype?view=netframework-4.8#System_Linq_Expressions_ExpressionType_Add

巴特西

C# 表达式树 Expression

最新文章

热门文章