经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C# » 查看文章
用lambda表达式树优化反射
来源：cnblogs　　作者：Fode　　时间：2018/12/7 9:37:50　　对本文有异议

本节重点不讲反射机制，而是讲lambda表达式树来替代反射中常用的获取属性和方法，来达到相同的效果但却比反射高效。

每个人都知道，用反射调用一个方法或者对属性执行SetValue和GetValue操作的时候都会比直接调用慢很多，这其中设计到CLR中内部的处理，不做深究。然而，我们在某些情况下又无法不使用反射，比如：在一个ORM框架中，你要将一个DataRow转化为一个对象，但你又不清楚该对象有什么属性，这时候你就需要写一个通用的泛型方法来处理，以下代码写得有点恶心，但不妨碍理解意思:

 

  1. 　　　　 //将DataReader转化为一个对象
    　　　　 private     static T GetObj<T>(SqliteDataReader reader) where T : class
  2.         {
  3.             T obj = new T();
  4.             PropertyInfo[] pros = obj.GetType().GetProperties();
  5.             foreach (PropertyInfo item in pros)
  6.             {
  7.                 try
  8.                 {
  9.                     Int32 Index = reader.GetOrdinal(item.Name);
  10.                     String result = reader.GetString(Index);
  11.                     if (typeof(String) == item.PropertyType)
  12.                     {
  13.                         item.SetValue(obj, result);
  14.                         continue;
  15.                     }
  16.                     if (typeof(DateTime) == item.PropertyType)
  17.                     {
  18.                         item.SetValue(obj, Convert.ToDateTime(result));
  19.                         continue;
  20.                     }
  21.                     if (typeof(Boolean) == item.PropertyType)
  22.                     {
  23.                         item.SetValue(obj, Convert.ToBoolean(result));
  24.                         continue;
  25.                     }
  26.                     if (typeof(Int32) == item.PropertyType)
  27.                     {
  28.                         item.SetValue(obj, Convert.ToInt32(result));
  29.                         continue;
  30.                     }
  31.                     if (typeof(Single) == item.PropertyType)
  32.                     {
  33.                         item.SetValue(obj, Convert.ToSingle(result));
  34.                         continue;
  35.                     }
  36.                     if (typeof(Single) == item.PropertyType)
  37.                     {
  38.                         item.SetValue(obj, Convert.ToSingle(result));
  39.                         continue;
  40.                     }
  41.                     if (typeof(Double) == item.PropertyType)
  42.                     {
  43.                         item.SetValue(obj, Convert.ToDouble(result));
  44.                         continue;
  45.                     }
  46.                     if (typeof(Decimal) == item.PropertyType)
  47.                     {
  48.                         item.SetValue(obj, Convert.ToDecimal(result));
  49.                         continue;
  50.                     }
  51.                     if (typeof(Byte) == item.PropertyType)
  52.                     {
  53.                         item.SetValue(obj, Convert.ToByte(result));
  54.                         continue;
  55.                     }
  56.                 }
  57.                 catch (ArgumentOutOfRangeException ex)
  58.                 {
  59.                     continue;
  60.                 }
  61.             }
  62.             return obj;
  63.         }

 

　　对于这种情况，其执行效率是特别低下的，具体多慢在下面例子会在.Net Core平台上和.Net Framework4.0运行测试案例.对于以上我举例的情况，效率上我们还可以得到提升。但对于想在运行时修改一下属性的名称或其他操作，反射还是一项特别的神器，因此在某些情况下反射还是无法避免的。

但是对于只是简单的SetValue或者GetValue，包括用反射构造函数，我们可以想一个中继的方法，那就是使用表达式树。对于不理解表达式树的，可以到微软文档查看，点击我。表达式树很容易通过对象模型表示表达式，因此强烈建议学习。查看以下代码：

  1.         static void Main()
  2.         {
  3.             Dog dog = new Dog();
  4.             PropertyInfo propertyInfo = dog.GetType().GetProperty(nameof(dog.Name));  //获取对象Dog的属性
  5.             MethodInfo SetterMethodInfo = propertyInfo.GetSetMethod();  //获取属性Name的set方法
  7.             ParameterExpression param = Expression.Parameter(typeof(Dog), "param");
  8.             Expression GetPropertyValueExp = Expression.Lambda(Expression.Property(param, nameof(dog.Name)), param);
  9.             Expression<Func<Dog, String>> GetPropertyValueLambda = (Expression<Func<Dog, String>>)GetPropertyValueExp;
  10.             ParameterExpression paramo = Expression.Parameter(typeof(Dog), "param");
  11.             ParameterExpression parami = Expression.Parameter(typeof(String), "newvalue");
  12.             MethodCallExpression MethodCallSetterOfProperty = Expression.Call(paramo, SetterMethodInfo, parami);
  13.             Expression SetPropertyValueExp = Expression.Lambda(MethodCallSetterOfProperty, paramo, parami);
  14.             Expression<Action<Dog, String>> SetPropertyValueLambda = (Expression<Action<Dog, String>>)SetPropertyValueExp;
  16.             //创建了属性Name的Get方法表达式和Set方法表达式,当然只是最简单的
  17.             Func<Dog, String> Getter = GetPropertyValueLambda.Compile(); 
  18.             Action<Dog, String> Setter = SetPropertyValueLambda.Compile();
  20.             Setter?.Invoke(dog, "WLJ");  //我们现在对dog这个对象的Name属性赋值
  21.             String dogName = Getter?.Invoke(dog);  //获取属性Name的值
  22.             
  23.             Console.WriteLine(dogName);
  24.             Console.ReadKey();
  25.         }
  27.         public class Dog
  28.         {
  29.             public String Name { get; set; }
  30.         }

 

 以下代码可能很难看得懂，但只要知道我们创建了属性的Get、Set这两个方法就行，其结果最后也能输出狗的名字 WLJ,拥有ExpressionTree的好处是他有一个名为Compile（）的方法，它创建一个代表表达式的代码块。现在是最有趣的部分，假设你在编译时不知道类型（在这篇文章中包含的代码我在不同的程序集上创建了一个类型）你仍然可以应用这种技术，我将对于常用的属性的set，get操作进行分装。

  1.        　　/// <summary>
  2.     　　/// 属性类，仿造反射中的PropertyInfo
  3.     /// </summary>
  4.     　　public class Property
  5.     {
  7.         private readonly PropertyGetter getter;
  8.         private readonly PropertySetter setter;
  9.         public String Name { get; private set; }
  11.         public PropertyInfo Info { get; private set; }
  13.         public Property(PropertyInfo propertyInfo)
  14.         {
  15.             if (propertyInfo == null)
  16.                 throw new NullReferenceException("属性不能为空");
  17.             this.Name = propertyInfo.Name;
  18.             this.Info = propertyInfo;
  19.             if (this.Info.CanRead)
  20.             {
  21.                 this.getter = new PropertyGetter(propertyInfo);
  22.             }
  24.             if (this.Info.CanWrite)
  25.             {
  26.                 this.setter = new PropertySetter(propertyInfo);
  27.             }
  28.         }
  31.         /// <summary>
  32.         　　 /// 获取对象的值
  33.         /// </summary>
  34.         　　/// <param name="instance"></param>
  35.         　　/// <returns></returns>
  36.         　　 public Object GetValue(Object instance)
  37.         {
  38.             return getter?.Invoke(instance);
  39.         }
  42.         /// <summary>
  43.         　　 /// 赋值操作
  44.         /// </summary>
  45.         　　/// <param name="instance"></param>
  46.         　　/// <param name="value"></param>
  47.         　　 public void SetValue(Object instance, Object value)
  48.         {
  49.             this.setter?.Invoke(instance, value);
  50.         }
  52.         private static readonly ConcurrentDictionary<Type, Core.Reflection.Property[]> securityCache = new ConcurrentDictionary<Type, Property[]>();
  54.         public static Core.Reflection.Property[] GetProperties(Type type)
  55.         {
  56.             return securityCache.GetOrAdd(type, t => t.GetProperties().Select(p => new Property(p)).ToArray());
  57.         }
  59.     }
  61.      /// <summary>
  62.     　　/// 属性Get操作类
  63.      /// </summary>
  64.    　　 public class PropertyGetter
  65.      {
  66.         private readonly Func<Object, Object> funcGet;
  68.         public PropertyGetter(PropertyInfo propertyInfo) : this(propertyInfo?.DeclaringType, propertyInfo.Name)
  69.         {
  71.         }
  73.         public PropertyGetter(Type declareType, String propertyName)
  74.         {
  75.             if (declareType == null)
  76.             {
  77.                 throw new ArgumentNullException(nameof(declareType));
  78.             }
  79.             if (propertyName == null)
  80.             {
  81.                 throw new ArgumentNullException(nameof(propertyName));
  82.             }
  86.             this.funcGet = CreateGetValueDeleagte(declareType, propertyName);
  87.         }
  90.         //代码核心部分
  91.        　　   private static Func<Object, Object> CreateGetValueDeleagte(Type declareType, String propertyName)
  92.         {
  93.             // (object instance) => (object)((declaringType)instance).propertyName
  95.             　　　　var param_instance = Expression.Parameter(typeof(Object));
  96.             var body_objToType = Expression.Convert(param_instance, declareType);
  97.             var body_getTypeProperty = Expression.Property(body_objToType, propertyName);
  98.             var body_return = Expression.Convert(body_getTypeProperty, typeof(Object));
  99.             return Expression.Lambda<Func<Object, Object>>(body_return, param_instance).Compile();
  100.         }
  102.         public  Object Invoke(Object instance)
  103.         {
  104.             return this.funcGet?.Invoke(instance);
  105.         }
  106.     }

  108.   　public class PropertySetter
  109.     {
  110.         private readonly Action<Object, Object> setFunc;
  112.         public PropertySetter(PropertyInfo property)  
  113.         {
  114.             if (property == null)
  116.             {
  117.                 throw new ArgumentNullException(nameof(property));
  118.             }
  119.             this.setFunc = CreateSetValueDelagate(property);
  120.         }
  124.         private static Action<Object, Object> CreateSetValueDelagate(PropertyInfo property)
  125.         {
  126.             // (object instance, object value) => 
  127.             //     ((instanceType)instance).Set_XXX((propertyType)value)
  129.             //声明方法需要的参数
  130.             var param_instance = Expression.Parameter(typeof(Object));
  131.             var param_value = Expression.Parameter(typeof(Object));
  133.             var body_instance = Expression.Convert(param_instance, property.DeclaringType);
  134.             var body_value = Expression.Convert(param_value, property.PropertyType);
  135.             var body_call = Expression.Call(body_instance, property.GetSetMethod(), body_value);
  137.             return Expression.Lambda<Action<Object, Object>>(body_call, param_instance, param_value).Compile();
  138.         }
  140.         public void Invoke(Object instance, Object value)
  141.         {
  142.             this.setFunc?.Invoke(instance, value);
  143.         }
  144.     }

在将代码应用到实例：

  1.             Dog dog = new Dog();
  2.             PropertyInfo propertyInfo = dog.GetType().GetProperty(nameof(dog.Name));
  3.             
  4.             //反射操作
  5.             propertyInfo.SetValue(dog, "WLJ");
  6.             String result = propertyInfo.GetValue(dog) as String;
  7.             Console.WriteLine(result);
  8.             
  9.             //表达式树的操作
  10.             Property property = new Property(propertyInfo);
  11.             property.SetValue(dog, "WLJ2");
  12.             String result2 = propertyInfo.GetValue(dog) as String;
  13.             Console.WriteLine(result2);

发现其实现的目的与反射一致，但效率却有明显的提高。

以下测试以下他们两之间的效率。测试代码如下：

  1. 　　　　　　　Student student = new Student();
  2.             PropertyInfo propertyInfo = student.GetType().GetProperty(nameof(student.Name));
  3.             Property ExpProperty = new Property(propertyInfo);
  5.             Int32 loopCount = 1000000;
  6.             CodeTimer.Initialize();  //测试环境初始化
  8.             //下面该方法个执行1000000次
  10.             CodeTimer.Time("基础反射", loopCount, () => { 
  11.                 propertyInfo.SetValue(student, "Fode",null);
  12.             });
  13.             CodeTimer.Time("lambda表达式树", loopCount, () => {
  14.                 ExpProperty.SetValue(student, "Fode");
  15.             });
  16.             CodeTimer.Time("直接赋值", loopCount, () => {
  17.                 student.Name = "Fode";
  18.             });
  19.             Console.ReadKey();

其.Net4.0环境下运行结果如下：

.Net Core环境下运行结果：

 

从以上结果可以知道，迭代同样的次数反射需要183ms，而用表达式只要34ms，直接赋值需要7ms，在效率上，使用表达式这种方法有显著的提高，您可以看到使用此技术可以完全避免使用反射时的性能损失。反射之所以效率有点低主要取决于其加载的时候时在运行期下，而表达式则在编译期，下篇有空将会介绍用Emit技术优化反射，会比表达式略快一点。

注：对于常用对象的属性，最好将其缓存起来，这样效率会更高。。

代码下载

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C#热门文章

  • NPOI的Excel的读取和写入
  • 事务在c#中的使用
  • 基于欧姆龙PLC#FinsTcp协议上位机通讯(二)-C#通讯模块开发
  • C# 当前 .NET SDK 不支持将 .NET Core 2.1 设置为目标。请将 .NET Core 2.0 或更低版本设置为目标，或使用支持 .NET Core 2.1 的 .NET SDK 版本。
  • C#读写Excel的几种方法
  • C#NPOI操作Excel，实现Excel数据导入导出（支持多个sheet）
  • c#中token的使用方法实例
  • OrderBy和OrderByDescending排序
  • C#中的modbus&nbsp;Tcp协议的数据抓取和使用解析
  • C#Aspose操作Word &amp; Excel简版（后会研究补充更多功能）

    • C#推荐文章

  • .NET 9 优化，抢先体验 C# 13 新特性
  • 使用C#爬取快手作者主页，并下载视频/图集(附源码及软件下载链接)
  • 聊一聊 C# 中让人惶恐的 Bitmap
  • C#/.NET/.NET Core技术前沿周刊 | 第 2 期（2024年8.19-8.25）
  • Elsa V3学习之Flowchart详解（上）
  • C#模拟键盘输入、键状态和监听键盘消息
  • 可以调用Null的实例方法吗？
  • SemanticKernel/C#：实现接口，接入本地嵌入模型
  • C#.Net筑基-解密委托与事件
  • C#/.NET/.NET Core优秀项目和框架2024年7月简报

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号