ExpressionTree——让反射性能向硬编码看齐

最新推荐文章于 2021-11-14 21:52:36 发布
最新推荐文章于 2021-11-14 21:52:36 发布
阅读量128 收藏
点赞数
原文链接：http://www.cnblogs.com/lightluomeng/p/4375713.html
版权

缘起

最近又换了工作。然后开心是以后又能比较频繁的关注博客园了。办离职手续的这一个月梳理了下近一年自己写的东西，然后就有了此文以及附带的代码。

反射

关于反射，窃以为，他只是比较慢。在这个前提下，个人认为只有在进行集合操作的时候谈论反射的性能才有意义。同时，只有在这个集合达到一定规模的时候，才有改进的余地。比如说，1000个元素的集合。后文会给出详细的数据。

关于ExpressionTree的介绍

借花献佛：

http://www.cnblogs.com/ASPNET2008/archive/2009/05/22/1485888.html

http://www.cnblogs.com/jams742003/archive/2009/12/23/1630432.html

实现

先给例子，再来探讨为什么。这里是几个Case：

1.根据属性名提取一个IEnuerable<object>集合元素的属性/字段的值。

2.根据属性名更新上诉对象的元素的属性/字段值。

3.将上诉集合投影为指定元素类型的集合。

以下是针对这3个Case的实现：

1.加载属性

using System;
using System.Collections.Generic;
using System.Linq;
using System.Caching;
using System.Text;
using System.Extension;
using System.Collections.Concurrent;

namespace System.Linq.Expressions
{
    public class PropertyFieldLoader : CacheBlock<string, Func<object, object>>
    {
        protected PropertyFieldLoader() { }

        public object Load(object tObj, Type type, string propertyPath)
        {
            return Compile(type, propertyPath)(tObj);
        }

        public T Load<T>(object tObj, Type type, string propertyPath)
            where T : class
        {
            return Load(tObj, type, propertyPath) as T;
        }

        public Func<object, object> Compile(Type type, string propertyPath)
        {
            var key = "Get_" + type.FullName + "_";
            var func = this.ConcurrentDic.GetOrAdd(key + "." + propertyPath, (string k) =>
            {
                ParameterExpression paramInstance = Expression.Parameter(typeof(object), "obj");
                Expression expression = Expression.Convert(paramInstance, type);
                foreach (var pro in propertyPath.Split('.'))
                    expression = Expression.PropertyOrField(expression, pro);
                expression = Expression.Convert(expression, typeof(object));
                var exp = Expression.Lambda<Func<object, object>>(expression, paramInstance);
                return exp.Compile();
            });
            return func;
        }

        public static PropertyFieldLoader Instance = new PropertyFieldLoader();
    }
}

2.更新属性

using System;
using System.Collections.Generic;
using System.Linq;
using System.Caching;
using System.Text;
using System.Extension;
using System.Collections.Concurrent;

namespace System.Linq.Expressions
{
    public class PropertyFieldSetter : CacheBlock<string, Action<object, object>>
    {
        protected PropertyFieldSetter() { }

        public void Set(object obj, string propertyPath, object value)
        {
            var tObj = obj.GetType();
            var tValue = value.GetType();
            var act = Compile(tObj, tValue, propertyPath);
            act(obj, value);
        }

        public static PropertyFieldSetter Instance = new PropertyFieldSetter();

        public Action<object, object> Compile(Type typeObj,Type typeValue, string propertyPath)
        {
            var key = "Set_" + typeObj.FullName + "_" + typeValue.FullName;
            var act = ConcurrentDic.GetOrAdd(key + "." + propertyPath, (s) =>
            {
                ParameterExpression paramInstance = Expression.Parameter(typeof(object), "obj");
                ParameterExpression paramValue = Expression.Parameter(typeof(object), "value");
                Expression expression = Expression.Convert(paramInstance, typeObj);
                foreach (var pro in propertyPath.Split('.'))
                    expression = Expression.PropertyOrField(expression, pro);
                var value = Expression.Convert(paramValue, typeValue);
                expression = Expression.Assign(expression, value);
                var exp = Expression.Lambda<Action<object, object>>(expression, paramInstance, paramValue);
                return exp.Compile();
            });
            return act;
        }
    }
}

3.数据转换

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Caching;

namespace System.Linq.Expressions
{
    public class DataTransfer<T> : CacheBlock<string, Func<object, T>>
         where T : new()
    {
        protected DataTransfer() { }

        public Func<object, T> Compile(Type inType)
        {
            var outType = typeof(T);
            var pKey = "Transfer_" + inType.FullName + "_" + outType.FullName;

            var func = this.ConcurrentDic.GetOrAdd(pKey, (string ckey) =>
            {
                var proOrFie = outType.GetProperties().Cast<MemberInfo>()
                    .Union(outType.GetFields().Cast<MemberInfo>())
                    .Union(inType.GetProperties().Cast<MemberInfo>())
                    .Union(inType.GetFields().Cast<MemberInfo>())
                    .GroupBy(i => i.Name).Where(i => i.Count() == 2)
                    .ToDictionary(i => i.Key, i => i);

                var returnTarget = Expression.Label(outType);
                var returnLabel = Expression.Label(returnTarget, Expression.Default(outType));
                var pramSource = Expression.Parameter(typeof(object));
                var parmConverted = Expression.Convert(pramSource, inType);
                var newExp = Expression.New(outType);
                var variate = Expression.Parameter(outType, "instance");
                var assVar = Expression.Assign(variate, newExp);

                Expression[] expressions = new Expression[proOrFie.Count + 3];
                expressions[0] = assVar;
                var assExps = proOrFie.Keys.Select(i =>
                    {
                        var value = Expression.PropertyOrField(parmConverted, i);
                        var prop = Expression.PropertyOrField(variate, i);
                        var assIgnExp = Expression.Assign(prop, value);
                        return assIgnExp;
                    });
                var index = 1;
                foreach (var exp in assExps)
                {
                    expressions[index] = exp;
                    index++;
                }

                expressions[index] = Expression.Return(returnTarget,variate);
                expressions[index + 1] = returnLabel;
                var block = Expression.Block(new[] { variate }, expressions);

                var expression = Expression.Lambda<Func<object, T>>(block, pramSource);
                return expression.Compile();
            });

            return func;
        }

        public static DataTransfer<T> Instance = new DataTransfer<T>();
    }
}

性能测试

首先，使用ExpressionTree在第一次调用的时候，会产生非常明显的性能开销。所以，在进行测试之前，都会对各个方法预调用一次，从而缓存ET（简写）的编译（不带引号）结果。同事，为了公平起见，对比的基于反射实现的代码页进行了略微的处理。

对比代码：

1.加载属性

() => ducks.Select(i => pro.GetValue(i)).ToArray()

2.更新属性

foreach (var duck in ducks) { pro.SetValue(duck, "AssignedReflection"); }

3.数据转换

public static Dictionary<string, Tuple<PropertyInfo, PropertyInfo>> Analyze(Type ts, Type to)
        {
            var names = to.GetProperties()
               .Union(ts.GetProperties())
               .GroupBy(i => i.Name).Where(i => i.Count() == 2)
               .Select(i => i.Key);
            var result = ts.GetProperties()
                .Where(i => names.Contains(i.Name)).OrderBy(i => i.Name)
                .Zip(to.GetProperties().Where(i => names.Contains(i.Name)).OrderBy(i => i.Name), (a, b) => new { Key = a.Name, Item1 = a, Item2 = b })
                .ToDictionary(i => i.Key, i => new Tuple<PropertyInfo, PropertyInfo>(i.Item1, i.Item2));
            return result;
        }

        /// <summary>
        /// Item1:Source,Item2:Target
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="OutT"></typeparam>
        /// <param name="source"></param>
        /// <param name="refResult"></param>
        /// <returns></returns>
        public static IEnumerable<OutT> TransferByReflection<T, OutT>(IEnumerable<T> source,
            Dictionary<string, Tuple<PropertyInfo, PropertyInfo>> refResult) where OutT : new()
        {
            foreach (var sor in source)
            {
                var target = new OutT();
                foreach (var p in refResult)
                {
                    object value = p.Value.Item1.GetValue(sor, null);
                    p.Value.Item2.SetValue(target, value);
                }
                yield return target;
            }
        }

同时还和对应的硬编码进行了对比，这里就不贴代码了。以下是结果（Tick为时间单位（1/10000毫秒））：

ExpressionTreeNativeCodeReflectionArrayLenthBenefitsAction
26122110-5AccessProperty
49249010041AccessProperty
2241408421000618AccessProperty
220112947807100005606AccessProperty
35884147307733610000041452AccessProperty
2238651386307893351000000565470AccessProperty
      
ExpressionTreeNativeCodeReflectionArrayLenthBenefitsAction
14517103AssignValue
231010110078AssignValue
109459831000874AssignValue
93141010542100009611AssignValue
94373720116147100000106710AssignValue
948954539210644711000000969576AssignValue
      
ExpressionTreeNativeCodeReflectionArrayLenthBenefitsAction
47111110-36TransferData
10146744100643TransferData
538240700410006466TransferData
49452331777581000072813TransferData
9183123606785472100000693641TransferData
960657681635802224510000007061588TransferData

同时，这里附上对应的图表：

由以上图表可知，当元素小于1000个的时候，收益不会超过1毫秒。所以，此时的改进空间可以说是几乎没有。当然，如果在整个项目中有很多地方，比如说...1000个地方，使用了类似的代码（反射），确实会导致性能问题。但这已经不是[反射]的错了。

原理和理解

上诉代码做的事情其实只有一件：“将逻辑缓存起来。”为什么说是将逻辑缓存起来？这是因为个人觉得，ET其实是描述代码逻辑的一种手段，和编程语言差不到哪里去了。只不过它编译的时候没有语法解析这一步。所以和调用编译器动态编译相比，“性能更好”也更轻量（臆测）。

而“为什么ET比反射快”，这个问题实际上应该是“为什么反射比ET慢”。反射调用的时候，首先要搜索属性，然后进行操作的时候又要进行大量的类型转换和校验。而对于ET而言，这些操作会在第一次完成之后“固定”并缓存起来。

收获

通过此次探讨，我们收获了什么呢？

1.只要小心一点，反射根本不是噩梦，让那些反射黑闭嘴。

2.就算反射导致了问题，我们仍然有办法解决。从以上数据来看，耗时为硬编码的两倍左右。如果2X->∞，那X也好不到哪里去。

3.好用。通过这种方式，我们能非常方便的访问“属性的属性”。比如：

 ducks.SelectPropertyOrField<Duck, object>("Name.Length")

4.更多可能性。我们甚至可以在不产生太大的性能开销的情况下完成一个深拷贝组件，来实现一定程度上通用的深拷贝。

附件

这里附上我使用的代码，供大家参考。

http://pan.baidu.com/s/1c0dF3FE（OneDrive不给力）

转载于:https://www.cnblogs.com/lightluomeng/p/4375713.html

weixin_33941350
关注
AEJoy —— 彻底搞懂 AE 各种 loop* 表达式【一】
ShaderJoy 的兴趣技术杂货铺
09-10 1万+
通过阅读本文，您将收获以下知识点loopInloopOut以及它们各自在不同type和duration下的区别；本文默认您已经具备了 AE 中关键帧（KeyFrame）的基础概念，并且以下的演示都是基于 4 个关键帧（依次从左到右）小车，如下所示4 个关键帧，当前小车处在第三个关键帧的 Position我们先从比较简单loopOut开始（loopIn的思维稍稍有点反人类，但是转过弯来就容易理解了）
C# 使用反射获取私有属性的方法
lindexi
04-16 6372
本文告诉大家多个不同的方法使用反射获得私有属性，最后通过测试性能发现所有的方法的性能都差不多
硬编码 and 软编码
feixingyuanhongzhu的博客
05-18 874
硬编码： 什么是“硬编码”？ “硬”，顾名思义，就是死板，一次性的意思。其定义也就是“将可变变量用一个固定数值表示”，这种方式在编码的过程中会导致变量很难修改。因此通常采用的方式都是软编码的方式， 软编码： 通过一个标记取代变量名称，而这个标记的值是可以不断变化的。但标记名称却是不变的，从而实现了“以不变应万变“。 硬编码和软编码的区别是： 软编码可以在运行时确定，修改；而硬编码是不能够改变的。 ...
Expression 反射调用TryParse
织梦行云
10-13 1117
public static class StringExtenssion { /// /// TryParse委托 /// /// String /// Out T /// 返回值 /// 要转换的字符串 /// out 输出参数 /// 成功
利用表达式树Expression优化反射性能
design_in_1988的博客
11-12 591
最近做了一个.Net Core环境下，基于NPOI的Excel导入导出以及Word操作的服务封装，涉及到大量反射操作，在性能优化过程中使用到了表达式树，记录一下。 Excel导入是相对比较麻烦的一块，实现的效果是：调用方只需要定义一个类，只需要标记特性，服务读取Excel=>校验(正则、必填、整数范围、日期、数据库是否存在、数据重复) =>将校验结果返回 => 提供方...
SqlHelper简单实现（通过Expression和反射）1.引言
weixin_30588827的博客
11-28 83
之前老大说要改变代码中充斥着各种Select的Sql语句字符串的情况，让我尝试着做一个简单的SqlHelper，要具有以下功能： 1.不要在业务代码中暴露DataTable或者DataSet类型； 2.可以完成Select操作，需要支持条件查询，分页，单条记录查询，排序，连表，单个值； 3.可以完成添加单条记录，添加多条记录，修改记录和删除记录； 4.使用过程中要兼容老代码，既允许直接传入...
Expression Tree 上手指南 （三）
weixin_33924312的博客
09-08 103
上回我们说到手工解析Expression Tree，以便获得其中的逻辑或者执行我们自定义的语义动作。这种做法扩展了C#语言的威力，让我们可以用C#的语法来做更多的事情，例如Linq to Sql。今天我们要学习一种相反的做法，手工创建表达式树，然后让.NET来解析它。这是一种强大的动态编程手段。我们可以用它来完成许多以前需要Reflection.Emit才能完成的任务。 LambdaExpress...
采用表达式树(Expression Tree)对一个对象的属性进行“遍历”
kmguo的专栏
02-26 9713
除去直接对类进行访问的方式之外，目前已经有三种方式，可以读取一个未知类型的对象的属性或字段。第一种也就是最常见的反射了，实现起来较为简单，但是如果每次要访问同一个类型的大量对象，则性能很差。第二种是采用Delegate的方式，参见：《采用Delegate对一个对象进行遍历，http://blog.csdn.net/kmguo/article/details/17392185》 这种方式也有缺点，就
.NET/C# 反射的的性能数据，以及高性能开发建议（反射获取 Attribute 和反射调用方法）
walterlv - 吕毅
11-05 2539
大家都说反射耗性能，但是到底有多耗性能，哪些反射方法更耗性能；这些问题却没有统一的描述。 本文将用数据说明反射各个方法和替代方法的性能差异，并提供一些反射代码的编写建议。为了解决反射的性能问题，你可以遵循本文采用的各种方案。 本文内容反射各方法的性能数据反射的高性能开发建议创建类型的实例反射获取 Attribute反射调用公共 / 私有方法使用预编译框架附本文性能测试所用的代码所有反射相关方法I...
数据结构与算法习题 Expression Expression tree Expression evaluation(栈与树结构综合)
PKU_ZZY的博客
10-14 1425
数据结构与算法习题 Expression Expression tree Expression evaluation(栈与树结构综合)
JUEL 学习笔记-(1)
xiaocddc的专栏
01-05 3939
表达式本质上类似于计算机编程语言的求值语句，它需要进行编译，词法／语法解析、变量／函数映射、求值、存储等一系列步骤串联起来进行求值。 JUEL实现了UEL("通用表达式语言")的接口，并扩展出一些类型定义以便能够被更加容易地使用。 JUEL基本框架 1. 表达式工厂（ExpressionFactory/ExpressionFactoryImpl）： UEL整体上使用的是虚拟工厂创建型模...
java中关于Tree的操作的小例子
chenshuang_com的专栏
06-21 3468
1、定义一个cs结构的界面： import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JScrollPane; import javax.swing.JTree; public class Test {     pub
在C#中使用Expression代替反射获取动态类中的值
聂绍举的博客
01-20 1338
1
关于EFCore中mysql使用Contains查询慢问题
风轻云断的博客
01-11 3094
文章目录一、关于`EFCore`中`mysql`使用`Contains`查询慢问题探究[^1]二、解决办法为使用`EF.Functions.Like`[^2]三、参考资料 一、关于EFCore中mysql使用Contains查询慢问题探究[^1] EFCore中Pomelo.EntityFrameworkCore.MySql将UserName.Contains(&quot;zyq&quot;)翻译为LOCATE('z...
C# 表达式目录树Expression
qq_29821795的博客
09-25 831
表达式目录树 表达式目录树：语法树，或者说是一种数据结构 1.表达式目录树Expression：System.Linq.Expressions; 2.描述了多个变量或者和常量之间的关系，按照一定的规则进行组装！ 可以向委托一样使用lambd表达式快捷声明； 不能有语句体，声明只能有一行代码； 可以通过Compile()，编译成一个委托； Func<int, int, int> func = (m, n) => { int i = 0; return m * n + 2;
表达式树，一种提高代码复用性的方式
无风听海
11-14 698
一、问题源起 在有些情况下，我们的计算逻辑跟传入数据的内部结构有关系，不仅不同的数据的计算逻辑不同，即使同一种数据结构的计算逻辑也会随时间变化；例如我们的大数据收集系统，需要根据前方业务人员配置的过滤表达式，来决定数据是否可以入库；那么我们就需要这个筛选的逻辑既要有通用性，也需要保证执行的高效性；那么表达式树或许是一种可能的选项； 二、什么是表达式树 表达式树是以类似树的结构来表达代码逻辑的一种方式；其中每一个节点都是一个表达式，例如一个方法调用或者赋值语句等。 我们可以编译表达式树，然后可以像普通方法那样
Expression.Compile() , Parameter out of scope 执行Expression获取结果
cxu123321的博客
06-22 686
Expression.Compile() , Parameter out of scope Ask Question Asked4 years, 9 months ago Active4 years, 9 months ago Viewed327 times 1 I am been messing with Expression Trees and I have hit a setback and can't find why or how to fix this : ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值