1.什么是表达式目录树 ：简单的说是一种语法树，或者说是一种数据结构（Expression）

2.用Lambda声明表达式目录树：

1
2
3
4
5
Expression<Func<int, int, int>> exp = (n, m) => n * m + 2; //表达试目录树的方法体只能是一行，不能有大括号。比如：
 //Expression<Func<int, int, int>> exp1 = (m, n) =>
 // {
 // return m * n + 2;
 // };

3.Expression.Compile();

1
2
3
4
Func<int, int, int> func = (m, n) => m * n + 2;
Expression<Func<int, int, int>> exp = (m, n) => m * n + 2;
int iResult1 = func.Invoke(99, 99);
int iResult2 = exp.Compile().Invoke(99, 99);

iResult1 和iResult2的结果一样，但是能Compile()的只有LambdaExpression。 Compile() 是将表达式树描述的 Lambda 表达式编译为可执行代码，并生成表示该 lambda 表达式的委托。exp.Compile().Invoke(99,99) 相当于这样调用 exp.Compile()();

4.認識表达式目录树结构。把上面的表达式拆分就是如下图，小学数学知识里的，按照运算符优先级别，先算乘法，m*n，得出结果再算加法，加上2。

如代码所示，m和n是参数，所以类型为ParameterExpression ，2是常量，常量类型是ConstantExpression ，MultiplyAssign 乘法，Add加法。第六步中只能执行表示Lambda表达式的表达式目录树，即LambdaExpression或者Expression<TDelegate>类型。如果表达式目录树不是表示Lambda表达式，需要调用Lambda方法创建一个新的表达式。actExpression.Compile()成委托，再调用。

1
2
3
4
5
6
7
8
9
10
{
    ParameterExpression left = Expression.Parameter(typeof(int), "m");//左边的参数
    ParameterExpression right = Expression.Parameter(typeof(int), "n");//右边的参数
    ConstantExpression constantlExp = Expression.Constant(2,typeof(int));//常量2
    BinaryExpression binaryExpMult = Expression.MultiplyAssign(left, right);//两个参数相乘
    BinaryExpression binaryExpAdd=Expression.Add(binaryExpMult, constantlExp);//相乘的结果再加2
    Expression<Func<int, int,int>> actExpression = Expression.Lambda<Func<int, int, int>>(binaryExpAdd, left, right);
    int result= actExpression.Compile()(2, 1);//调用
    Console.WriteLine(result+"");
}

一些表达式目录树常用的类型

5.表达式目录树+缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ThreeHomeWork.Model
{
 public class Student
 {
  public int Id { get; set; }
  public string Name { get; set; }
  public int Age { get; set; }
 }
 public class StudentDto
 {
  public int Id { get; set; }
  public string Name { get; set; }
  public int Age { get; set; }
 }
}

有时候一些业务模型和实体模型不太一样，比如Student 于StudentDto实体的转换

一般的写法,new 一个实体然后把值赋给另一个实体，有一个就写一个，有十个就写是个，代码写死了，硬编码性能高

1
2
3
4
5
6
7
8
9
{
    Student student = new Student() { Age = 12, Id=1, Name="晴天" };
    StudentDto studentDto = new StudentDto()
    {
     Name = student.Name,
     Id = student.Id,
     Age = student.Age
    };
   }

第二种：使用Expression表达式目录树

1
2
3
4
5
6
7
Expression<Func<Student, StudentDto>> lambda = p => new StudentDto
     {
      Age = p.Age,
      Id = p.Id,
      Name = p.Name
     };
     lambda.Compile().Invoke(student);

01.使用字典缓存表达式树，第一步是实例化了一个命令参数，parameterExpression，  List<MemberBinding> memberBindingList = new List<MemberBinding>();是一个对象成员集合列表，循环TOut的所有公共的属性和字段，Add到memberBindingList集合中，然后使用MemberInitExpression初始化多个对象拼装再调用。第一次调用动态拼装，组装了一个key放入字典中，缓存之后，就直接调用字典中的数据。缓存后的就是硬编码所以性能高。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
 
namespace ThreeHomeWork.MappingExtend
{
 /// <summary>
 /// 生成表达式目录树。字典缓存
 /// </summary>
 public class ExpressionMapper
 {
  private static Dictionary<string, object> _DIC = new Dictionary<string, object>();
 
  /// <summary>
  /// 字典缓存表达式树
  /// </summary>
  /// <typeparam name="TIn"></typeparam>
  /// <typeparam name="TOut"></typeparam>
  /// <param name="tIn"></param>
  /// <returns></returns>
  public static TOut Trans<TIn, TOut>(TIn tIn)
  {
   string key = string.Format("funckey_{0}_{1}", typeof(TIn).FullName, typeof(TOut).FullName);
   if (!_DIC.ContainsKey(key))
   {
    ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
    List<MemberBinding> memberBindingList = new List<MemberBinding>();
    foreach (var item in typeof(TOut).GetProperties())
    {
     MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
     MemberBinding memberBinding = Expression.Bind(item, property);
     memberBindingList.Add(memberBinding);
    }
    foreach (var item in typeof(TOut).GetFields())
    {
     MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name));
     MemberBinding memberBinding = Expression.Bind(item, property);
     memberBindingList.Add(memberBinding);
    }
    MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
    Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]
    {
     parameterExpression
    });
    Func<TIn, TOut> func = lambda.Compile();//拼装是一次性的
    _DIC[key] = func;
   }
   return ((Func<TIn, TOut>)_DIC[key]).Invoke(tIn);
  }
 
 }
}

02.泛型+反射，接收一个TIn类型的，返回一个TOut类型的反射，通过反射遍历赋值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ThreeHomeWork.MappingExtend
{
 public class ReflectionMapper
 {
  /// <summary>
  /// 反射
  /// </summary>
  /// <typeparam name="TIn"></typeparam>
  /// <typeparam name="TOut"></typeparam>
  /// <param name="tIn"></param>
  /// <returns></returns>
  public static TOut Trans<TIn, TOut>(TIn tIn)
  {
   TOut tOut = Activator.CreateInstance<TOut>();//创建对象
   foreach (var itemOut in tOut.GetType().GetProperties())//遍历属性
   {
    foreach (var itemIn in tIn.GetType().GetProperties())
    {
     if (itemOut.Name.Equals(itemIn.Name))
     {
      itemOut.SetValue(tOut, itemIn.GetValue(tIn));
      break;
     }
    }
   }
   foreach (var itemOut in tOut.GetType().GetFields())//遍历字段
   {
    foreach (var itemIn in tIn.GetType().GetFields())
    {
     if (itemOut.Name.Equals(itemIn.Name))
     {
      itemOut.SetValue(tOut, itemIn.GetValue(tIn));
      break;
     }
    }
   }
   return tOut;
  }
 }
}

03.使用第三方序列化反序列化工具，Newtonsoft.Json是比较好的一个工具，这种方式序列化代码虽然一行搞定，但是序列化和反序列化的动作比反射动作大点，耗时会比较高。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ExpressionDemo.MappingExtend
{
 public class SerializeMapper
 {
  /// <summary>
  /// 序列化反序列化方式
  /// </summary>
  /// <typeparam name="TIn"></typeparam>
  /// <typeparam name="TOut"></typeparam>
  public static TOut Trans<TIn, TOut>(TIn tIn)
  {
   return JsonConvert.DeserializeObject<TOut>(JsonConvert.SerializeObject(tIn));
  }
 }
}

04.生成表达式目录树，泛型缓存，使用泛型缓存性能是最高的。动态实现Student与StudentDto的转换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace ThreeHomeWork.MappingExtend
{
 /// <summary>
 /// 生成表达式目录树 泛型缓存
 /// </summary>
 /// <typeparam name="TIn"></typeparam>
 /// <typeparam name="TOut"></typeparam>
 public class ExpressionGenericMapper<TIn, TOut>//Mapper`2
 {
  private static Func<TIn, TOut> _FUNC = null;
  static ExpressionGenericMapper()
  {
   ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
   List<MemberBinding> memberBindingList = new List<MemberBinding>();
   foreach (var item in typeof(TOut).GetProperties())
   {
    MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
    MemberBinding memberBinding = Expression.Bind(item, property);
    memberBindingList.Add(memberBinding);
   }
   foreach (var item in typeof(TOut).GetFields())
   {
    MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name));
    MemberBinding memberBinding = Expression.Bind(item, property);
    memberBindingList.Add(memberBinding);
   }
   MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
   Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]
   {
     parameterExpression
   });
   _FUNC = lambda.Compile();//拼装是一次性的
  }
  public static TOut Trans(TIn t)
  {
   return _FUNC(t);
  }
 }
}

C#简单实现表达式目录树（Expression）的更多相关文章

  1. 05.表达式目录树Expression

    参考文章 https://www.cnblogs.com/xyh9039/p/12748983.html 1. 基本了解 1.1 Lambda表达式 演变过程 using System; namesp ...

  2. 表达式目录树(Expression)

    一:什么是表达式树 Expression我们称为是表达式树,是一种数据结构体,用于存储需要计算,运算的一种结构,这种结构可以只是存储,而不进行运算.通常表达式目录树是配合Lambda一起来使用的,la ...

  3. C#表达式目录树（Expression）

    1.什么是表达式目录树 :简单的说是一种语法树,或者说是一种数据结构(Expression) 2.用Lambda声明表达式目录树: Expression<Func<; //表达试目录树的方 ...

  4. 第十五节：Expression表达式目录树(与委托的区别、自行拼接、总结几类实例间的拷贝)

    一. 基本介绍 回忆: 最早接触到表达式目录树(Expression)可能要追溯到几年前使用EF早期的时候,发现where方法里的参数是Expression<Func<T,bool> ...

  5. MVC图片上传详解 IIS (安装SSL证书后) 实现 HTTP 自动跳转到 HTTPS C#中Enum用法小结 表达式目录树 “村长”教你测试用例 引用provinces.js的三级联动

    MVC图片上传详解   MVC图片上传--控制器方法 新建一个控制器命名为File,定义一个Img方法 [HttpPost]public ActionResult Img(HttpPostedFile ...

  6. 【手撸一个ORM】第五步、Expression(表达式目录树)转换为Where子句

    说明 在SQL中,查询.修改比较常用到WHERE子句,在这里根据使用场景不同,定义了两个类,一个用于查询,一个用于修改(插入)操作.原因是: 查询操作支持一级导航属性查询,如student.Schoo ...

  7. Expression表达式目录树

    一.初识Expression 1.在上一篇我们讲到了委托(忘记了可以在看看,点赞在看养成习惯),今天要讲的Expression也和委托有一点点关系吧(没有直接关系,只是想要大家看看我其他的文章),Ex ...

  8. 【学习笔记】Expression表达式目录树

    Expression表达式目录树:一个能拼装能解析的数据结构,语法树. 一.手动拼装表达式目录树 示例1: /// <summary> /// 展示表达式树,协助用的 /// 编译lamb ...

  9. 【手撸一个ORM】第四步、Expression（表达式目录树）扩展

    到这里,Orm的基架已经搭起来了,接下来就是激动人心的部分,表达式目录树转Sql语句,SqlDataReader转数据实体等等,但是在这之前,我们需要扩展下表达式目录树的方法,以方便后面的相关操作. ...

随机推荐

  1. [NOI2009] 诗人小G [题解]

    诗人小G 题目大意 给出 \(n\) 个长度不超过 \(30\) 的句子,要求你对其进行排版. 对于每一行,有一个规定的行标准长度 \(L\) ,每一行的不协调度等于该行的实际长度与行标准长度差的绝对 ...

  2. C语言：变量

    变量: 1.在程序运行过程中,值可以改变的量称为变量 2.每个变量都有一个名字,称为变量名 3.每个变量都必须进行变量说明,指明变量的类型 4.每个变量都有一个对应的地址,写法:&变量名 5. ...

  3. 论文阅读：Robust Visual SLAM with Point and Line Features

    本文提出了使用异构点线特征的slam系统,继承了ORB-SLAM,包括双目匹配.帧追踪.局部地图.回环检测以及基于点线的BA.使用最少的参数对线特征采用标准正交表示,推导了线特征重投影误差的雅克比矩阵 ...

  4. element取消全局loading

    背景 前两天在开发一个管理后台项目时, 遇到了一个问题,后端接口返回特别慢,由于该接口调用的是第三方API,无法通过后端去处理.此时想到用loading动画,但随之而来也产生了不少问题, 在此记录一下 ...

  5. Servlet 单例多线程详解（六）

    一.Servlet 单例多线程 Servlet如何处理多个请求访问?Servlet容器默认是采用单实例多线程的方式处理多个请求的:1.当web服务器启动的时候(或客户端发送请求到服务器时),Servl ...

  6. 动静态web项目（三）

    在Eclipse中将web项目分为了Dynamic Web Project和Static Web Project. 那么这两种有什么区别呢? 其实这里的Dynamic和Static是通过页面来区分的. ...

  7. 什么是jstl表达式，怎么应用

    1.介绍 JSTL(JSP Standard Tag Library),JSP标准标签库,可以嵌入在jsp页面中使用标签的形式完成业务逻辑等功能.jstl出现的目的同el一样也是要代替jsp页面中的脚 ...

  8. Python自动化测试面试题-经验篇

    目录 Python自动化测试面试题-经验篇 Python自动化测试面试题-用例设计篇 Python自动化测试面试题-Linux篇 Python自动化测试面试题-MySQL篇 Python自动化测试面试 ...

  9. 第二十九篇 -- UDP和TCP

    最近在写WIFI模块,所以就想明确一些TCP和UDP的区别,发现以前的理解还是有点误区.现在重新学习. 相同点 UDP协议和TCP协议都是传输层协议 TCP(Transmission Control ...

  10. 大数据学习（12）—— Hive Server2服务

    什么是Hive Server2 上一篇我们启动了hive --service metastore服务,可以通过命令行来访问hive服务,但是它不支持多客户端同时访问,参见官网说明:HiveServer ...