C#表达式目录树（Expression）_.NET_编程开发_程序员俱乐部

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

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

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

 3.Expression.Compile();

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

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

 5.表达式目录树+缓存

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

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

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

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

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

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

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

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

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

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

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

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

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

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

未完以后再续。