C#简单实现表达式目录树（Expression）

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

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

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

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

 3.Expression.Compile();

 Func<int,int> func = (m,n) => m * n + 2; Expression<Func<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.JR表达式目录树结构。把上面的表达式拆分就是如下图，小学数学知识里的，按照运算符优先级别，先算乘法，m*n，得出结果再算加法，加上2。

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

 {     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>> actExpression = Expression.Lambda<Func<int,int>>(binaryExpAdd,left,right);     int result= actExpression.Compile()(2,1);//调用     Console.Writeline(result+""); }

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

 5.表达式目录树+缓存

 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 一个实体然后把值赋给另一个实体，有一个就写一个，有十个就写是个，代码写死了，硬编码性能高

 {     Student student = new Student() { Age = 12,ID=1,name="晴天" };     StudentDto studentDto = new StudentDto()     {      name = student.name,ID = student.ID,Age = student.Age     };    }

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

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放入字典中，缓存之后，就直接调用字典中的数据。缓存后的就是硬编码所以性能高。

 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类型的反射，通过反射遍历赋值。

 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是比较好的一个工具，这种方式序列化代码虽然一行搞定，但是序列化和反序列化的动作比反射动作大点，耗时会比较高。

 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的转换。

 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,new ParameterExpression[]    {      parameterExpression    });    _FUNC = lambda.Compile();//拼装是一次性的   }   public static TOut Trans(TIn t)   {    return _FUNC(t);   }  } }

总结

以上所述是小编给大家介绍的C#简单实现表达式目录树（Expression），希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对编程小技巧网站的支持！

总结

以上是内存溢出为你收集整理的C#简单实现表达式目录树（Expression）全部内容，希望文章能够帮你解决C#简单实现表达式目录树（Expression）所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。