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 Student10 {11 public int Id { get; set; }12 public string Name { get; set; }13 public int Age { get; set; }14 }15 public class StudentDto16 {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.Age8 };9 }
第二种：使用Expression表达式目录树
1 Expression<Func<Student, StudentDto>> lambda = p => new StudentDto2 {3 Age = p.Age,4 Id = p.Id,5 Name = p.Name6 };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 ExpressionMapper14 {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 parameterExpression47 });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 ReflectionMapper10 {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 SerializeMapper11 {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`217 {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 parameterExpression39 });40 _FUNC = lambda.Compile();//拼装是一次性的41 }42 public static TOut Trans(TIn t)43 {44 return _FUNC(t);45 }46 }47 }
未完以后再续。
注：本文内容来自互联网，旨在为开发者提供分享、交流的平台。如有涉及文章版权等事宜，请你联系站长进行处理。