从本章节开始，所有的知识点只记录核心重点， 不做基础介绍，看知识点性质，偏向于理论则重理论

1.表达式目录树Expression

  2.     //1. 先看看委托  拉姆达表达式其实是作为委托的一个参数,本质是一个方法（匿名方法）
  3.         Func<int, int, int> func = (m, n) =>
  4.                 {
  5.                     int i = 0;
  6.                     return m * n + 2;
  7.                 };  
  8.     //2.再看表达式目录树， 其数据结构--就像对一个计算做了一个精确的描述，展开之后发现，分为左边，右边，每个元素都可以把值都获取出来，二叉树
  9.           Expression<Func<int, int, int>> exp = (m, n) => m * n + 2; 
  10.     //3.表达式目录树可以通过compile 转换成一个委托
  11.           var erpPlu= exp.Compile();
  12.     //4 注意：表达式目录树只能有一行；
  13.            Expression<Func<int, int, int>> exp1 = (m, n) => 
  14.         {
  15.                        return m * n + 2;
  16.         }; 
  17.      //5. Invoke(执行) 表达式目录树：语法树，或者说是一种数据结构
  18.          int iResult1 = func.Invoke(12, 23);
  19.          int iResult2 = exp.Compile().Invoke(12, 23);

2.动态拼装表达式目录树

  2.       //1. 目标是拼装如下表达式，首先反编译后看看大概代码，然后从右边往后拆分替换，
  3.      Expression<Func<People, bool>> lambda = x => x.Id.ToString().Equals("5");
  6.      ParameterExpression parameterExpression = Expression.Parameter(typeof(People), "x");
  7.      FieldInfo idfield = typeof(People).GetField("Id");
  8.      var idExp = Expression.Field(parameterExpression, idfield);
  9.      //int i = 0;
  10.      //i.ToString(); 
  11.      MethodInfo toString = typeof(int).GetMethod("ToString", new Type[0]);
  12.      //Expression.Call()调用方法
  13.      var toStringExp = Expression.Call(idExp, toString, Array.Empty<Expression>()); 
  14.      var Equals = typeof(string).GetMethod("Equals", new Type[] { typeof(string) });
  15.      Expression expressionConstant5 = Expression.Constant("5", typeof(string));
  16.      var equalsExp = Expression.Call(toStringExp, Equals, new Expression[]
  17.       {
  18.          expressionConstant5
  19.       });
  20.      Expression<Func<People, bool>> expression = Expression.Lambda<Func<People, bool>>(equalsExp, new ParameterExpression[]
  21.      {
  22.               parameterExpression
  23.      });
  24.      //转成委托
  25.      Func<People, bool> func = expression.Compile();
  26.      //调用
  27.      var bResult = func.Invoke(new People()
  28.      {
  29.          Id = 5,
  30.          Name = "海贝"
  31.      });
  33.     //测试
  34.      new List<People>().AsQueryable().Where(expression);

3.基于Expression的扩展应用

  1. 现有一需求 把 people 转化成 peoplecopy
  2.  {
  3.      People people = new People()
  4.      {
  5.          Id = 11,
  6.          Name = "张三",
  7.          Age = 31
  8.      };
  10.      //不能转换，因为没有父子级关系；
  11.      PeopleCopy copy = (PeopleCopy)people; 
  13.       //方式1 ：硬编码性能最高，扩展性不好，
  14.      PeopleCopy peopleCopy = new PeopleCopy()
  15.      {
  16.          Id = people.Id,
  17.          Name = people.Name,
  18.          Age = people.Age
  19.      };
  21.      //方式2：反射，性能问题  
  22.     PeopleCopy peopleCopy1 = ReflectionMapper.Trans<People, PeopleCopy>(people);
  23.     public class ReflectionMapper
  24.     {
  25.         /// <summary>
  26.         /// 反射
  27.         /// </summary>
  28.         /// <typeparam name="TIn"></typeparam>
  29.         /// <typeparam name="TOut"></typeparam>
  30.         /// <param name="tIn"></param>
  31.         /// <returns></returns>
  32.         public static TOut Trans<TIn, TOut>(TIn tIn)
  33.         {
  34.             TOut tOut = Activator.CreateInstance<TOut>();
  35.             foreach (var itemOut in tOut.GetType().GetProperties())
  36.             {
  37.                 var propIn = tIn.GetType().GetProperty(itemOut.Name);
  38.                 itemOut.SetValue(tOut, propIn.GetValue(tIn)); 
  39.             }
  41.             foreach (var itemOut in tOut.GetType().GetFields())
  42.             {
  43.                 var fieldIn = tIn.GetType().GetField(itemOut.Name);
  44.                 itemOut.SetValue(tOut, fieldIn.GetValue(tIn)); 
  45.             }
  46.             return tOut;
  47.         }
  48.     }  
  50.      //方式3:序列化反序列化,性能问题；
  51.      PeopleCopy peopleCopy2 = SerializeMapper.Trans<People, PeopleCopy>(people); 
  53.     /// <summary>
  54.     /// 使用第三方序列化反序列化工具
  55.     /// 还有automapper
  56.     /// </summary>
  57.     public class SerializeMapper
  58.     {
  59.         /// <summary>
  60.         /// 序列化反序列化方式
  61.         /// </summary>
  62.         /// <typeparam name="TIn"></typeparam>
  63.         /// <typeparam name="TOut"></typeparam>
  64.         public static TOut Trans<TIn, TOut>(TIn tIn)
  65.         {
  66.             return JsonConvert.DeserializeObject<TOut>(JsonConvert.SerializeObject(tIn));
  67.         }
  68.     }
  69. }
  2.     //方式4:生成表达式目录树 字典缓存
  3.     PeopleCopy peopleCopy4 = ExpressionMapper.Trans<People, PeopleCopy>(people);
  5.     /// <summary>
  6.     /// 生成表达式目录树 缓存
  7.     ///想办法去动态拼装这个委托，然后缓存下委托，后面再次转换时就没有性能损耗了    
  8.     /// </summary>
  9.     public class ExpressionMapper
  10.     {
  11.         /// <summary>
  12.         /// 字典缓存--hash分布
  13.         /// </summary>
  14.         private static Dictionary<string, object> _Dic = new Dictionary<string, object>();
  16.         /// <summary>
  17.         /// 字典缓存表达式树
  18.         /// </summary>
  19.         /// <typeparam name="TIn"></typeparam>
  20.         /// <typeparam name="TOut"></typeparam>
  21.         /// <param name="tIn"></param>
  22.         /// <returns></returns>
  23.         public static TOut Trans<TIn, TOut>(TIn tIn)
  24.         {
  25.             string key = string.Format("funckey_{0}_{1}", typeof(TIn).FullName, typeof(TOut).FullName);
  26.             if (!_Dic.ContainsKey(key))
  27.             {
  28.                 ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
  29.                 List<MemberBinding> memberBindingList = new List<MemberBinding>();
  30.                 foreach (var item in typeof(TOut).GetProperties())
  31.                 {
  32.                     MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
  33.                     //Bind 赋值
  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.     }
  56.     ///方式5： 生成表达式目录树  泛型缓存 （推荐性能最高，仅次于硬编码）
  57.     PeopleCopy peopleCopy6 = ExpressionGenericMapper<People, PeopleCopy>.Trans(people);
  59.     /// <summary>
  60.     /// 生成表达式目录树  泛型缓存
  61.     /// </summary>
  62.     /// <typeparam name="TIn"></typeparam>
  63.     /// <typeparam name="TOut"></typeparam>
  64.     public class ExpressionGenericMapper<TIn, TOut>//Mapper`2
  65.     {
  66.         private static Func<TIn, TOut> _FUNC = null;
  67.         static ExpressionGenericMapper()
  68.         {
  69.             ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
  70.             List<MemberBinding> memberBindingList = new List<MemberBinding>();
  71.             foreach (var item in typeof(TOut).GetProperties())
  72.             {
  73.                 MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
  74.                 MemberBinding memberBinding = Expression.Bind(item, property);
  75.                 memberBindingList.Add(memberBinding);
  76.             }
  77.             foreach (var item in typeof(TOut).GetFields())
  78.             {
  79.                 MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name));
  80.                 MemberBinding memberBinding = Expression.Bind(item, property);
  81.                 memberBindingList.Add(memberBinding);
  82.             }
  83.             MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
  84.             Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]
  85.             {
  86.                     parameterExpression
  87.             });
  88.             _FUNC = lambda.Compile();//拼装是一次性的
  89.         }
  90.         public static TOut Trans(TIn t)
  91.         {
  92.             return _FUNC(t);
  93.         }
  94.     }