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

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

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

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

3.expression.Compile();

 Func func = (m, n) => m * n + 2;
 expression> 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类型。如果表达式目录树不是表示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> actexpression = expression.Lambda>(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> lambda = p => new StudentDto
     {
      Age = p.Age,
      Id = p.Id,
      Name = p.Name
     };
     lambda.Compile().Invoke(student);

01.使用字典缓存表达式树，第一步是实例化了一个命令参数，parameterexpression， List memberBindingList = new List();是一个对象成员集合列表，循环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
 {
  /// 
  /// 生成表达式目录树。字典缓存
  /// 
  public class expressionMapper
  {
   private static Dictionary _DIC = new Dictionary();
 
   /// 
   /// 字典缓存表达式树
   /// 
   /// 
   /// 
   /// 
   /// 
   public static TOut Trans(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 memberBindingList = new List();
     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> lambda = expression.Lambda>(memberInitexpression, new Parameterexpression[]
     {
      parameterexpression
     });
     Func func = lambda.Compile();//拼装是一次性的
     _DIC[key] = func;
    }
    return ((Func)_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
  {
   /// 
   /// 反射
   /// 
   /// 
   /// 
   /// 
   /// 
   public static TOut Trans(TIn tIn)
   {
    TOut tOut = Activator.CreateInstance();//创建对象
    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
  {
   /// 
   /// 序列化反序列化方式
   /// 
   /// 
   /// 
   public static TOut Trans(TIn tIn)
   {
    return JsonConvert.DeserializeObject(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
 {
  /// 
  /// 生成表达式目录树 泛型缓存
  /// 
  /// 
  /// 
  public class expressionGenericMapper//Mapper`2
  {
   private static Func _FUNC = null;
   static expressionGenericMapper()
   {
    Parameterexpression parameterexpression = expression.Parameter(typeof(TIn), "p");
    List memberBindingList = new List();
    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> lambda = expression.Lambda>(memberInitexpression, new Parameterexpression[]
    {
      parameterexpression
    });
    _FUNC = lambda.Compile();//拼装是一次性的
   }
   public static TOut Trans(TIn t)
   {
    return _FUNC(t);
   }
  }
 }

总结

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

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

C#教程相关栏目本月热门文章