C#高级进阶教程_07_表达式目录树

Expression表达式目录树

表达式目录树，在c#中是Expression来定义的，它是一种语法树，或者说是一种数据结构。

其主要用于存储需要计算、运算的一种结构，它只提供存储功能，不进行运算。

Expression的方法体只能是一个整体，不能具有花括号。

Func<int, int, int> func = (m, n) => m * n + 2;              // new Func<int, int, int>((m, n) => m * n + 2);
 Expression<Func<int, int, int>> exp = (m, n) => m * n + 2;  //lambda表达式声明表达式目录树
                                                             //Expression<Func<int, int, int>> exp1 = (m, n) =>//只能一行 不能有大括号
                                                             //    {
                                                             //        return m * n + 2;
                                                             //    };
                                                             //Queryable    //a=>a.Id>3

 //表达式目录树：语法树，或者说是一种数据结构; 可以被我们解析
 int iResult1 = func.Invoke(12, 23);
 int iResult2 = exp.Compile().Invoke(12, 23);//可以转换过去  Compile编译

Lambda表达式是一种方法，Expression表达式目录树是一种数据结构（可以通过二叉树形式解析）

ORM框架，深入探索… …

1、用Lambda表达式快速声明Expression表达式目录树

Expression<Func<int, int, int>> exp = (m, n) => m * n + 2;

2、自主构建Expression表达式目录树

案例01

---

ParameterExpression parameterExpression =  Expression.Parameter(typeof(int), "m");  //定义参数“m”
ParameterExpression parameterExpression2 = Expression.Parameter(typeof(int), "n");  //定义参数“n”
var multiply = Expression.Multiply(parameterExpression, parameterExpression2);      //组建第一步的乘法
var constant = Expression.Constant(2, typeof(int));                                 //定义常数参数“2”
var add = Expression.Add(multiply, constant);                                       //组建第二步的加法

Expression<Func<int, int, int>> expression =Expression.Lambda<Func<int, int, int>>( //构建表达式目录树 
        add,                                                                        //使用的方法体
        new ParameterExpression[]                                                   //使用的参数
        {
             parameterExpression,
             parameterExpression2
        })

int iResult1 = exp.Compile().Invoke(11, 12);                            
int iResult2 = expression.Compile().Invoke(11, 12);                                  //编译为lambda表达式，调用

案例02

ParameterExpression parameterLeft =  Expression.Parameter(typeof(int), "m");//定义参数
ParameterExpression parameterRight = Expression.Parameter(typeof(int), "n");//定义参数
BinaryExpression binaryMultiply = Expression.Multiply(parameterLeft, parameterRight);//组建第一步的乘法             
ConstantExpression constant = Expression.Constant(2, typeof(int)); //定义常数参数
BinaryExpression binaryAdd = Expression.Add(binaryMultiply, constant);//组建第二步的加法
var expression = Expression.Lambda<Func<int, int, int>>(binaryAdd, parameterLeft, parameterRight);//构建表达式目录树     
var func = expression.Compile();  //编译为lambda表达式
int iResult3 = func(3, 2);
int iResult4 = expression.Compile().Invoke(3, 2);           
int iResult5 = expression.Compile()(3, 2);

案例03

ConstantExpression conLeft = Expression.Constant(345);
ConstantExpression conRight = Expression.Constant(456);
BinaryExpression binary = Expression.Add(conLeft, conRight);//345+456
Expression<Action> actExpression = Expression.Lambda<Action>(binary, null);//()=>345+456
//只能执行表示Lambda表达式的表达式目录树，即LambdaExpression或者Expression<TDelegate>类型。如果表达式目录树不是表示Lambda表达式，需要调用Lambda方法创建一个新的表达式
actExpression.Compile()();

练习一：

1、利用Lambda表达式快速声明Expression表达式目录树

---

Expression<Func<People, bool>> lambda = x => x.Id.ToString().Equals("5");

2、自主构建Expression表达式目录树（反编译或工具获得的）

ParameterExpression parameterExpression = Expression.Parameter(typeof(People), "x");          // 声明参数表达式x，声明一个参数对象
var field = Expression.Field(parameterExpression, typeof(People).GetField("Id"));             // 查找属性字段 “Id” ，typeof(People).GetField("Id")
var toString = typeof(People).GetMethod("ToString");                                          // 找到ToString（）方法
var toStringCall = Expression.Call(field, toString, new Expression[0]);                       
var equals = typeof(People).GetMethod("Equals");                                              // 找到字符串到的"Equals"方法

var constant =   Expression.Constant("5", typeof(string));
var equalsCall = Expression.Call(toStringCall, equals, new Expression[] { constant });        // 与常量进行比较

Expression<Func<People, bool>> expression =
    Expression.Lambda<Func<People, bool>>(equalsCall, new ParameterExpression[]
        {
          parameterExpression
        });

expression.Compile().Invoke(new People()                                                      //需要 传入People类型
{
    Id = 11,
    Name = "Eleven",
    Age = 31
});

ORM框架和EF

---

---

赏

谢谢你请我吃糖果

支付宝

微信

• 本文作者： 梁俊可
• 本文链接： http://ljk3d.com/2021/10/19/cSharpNote/CSharp高级进阶教程_07_表达式目录树/
• 版权声明： 梁俊可工作室