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

最新推荐文章于 2021-09-25 22:01:37 发布
最新推荐文章于 2021-09-25 22:01:37 发布
阅读量114 收藏
点赞数
原文链接：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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
expression tree.pptx
06-06
介绍了System.Linq.Expression命名空间下的Expression类以及如何执行和修改表达式树，最后介绍了表达式树用到的访问者模式。
Expression Tree 上手指南 （三）
weixin_33924312的博客
09-08 95
上回我们说到手工解析Expression Tree，以便获得其中的逻辑或者执行我们自定义的语义动作。这种做法扩展了C#语言的威力，让我们可以用C#的语法来做更多的事情，例如Linq to Sql。今天我们要学习一种相反的做法，手工创建表达式树，然后让.NET来解析它。这是一种强大的动态编程手段。我们可以用它来完成许多以前需要Reflection.Emit才能完成的任务。 LambdaExpress...
JUEL 学习笔记-(1)
xiaocddc的专栏
01-05 3859
表达式本质上类似于计算机编程语言的求值语句，它需要进行编译，词法／语法解析、变量／函数映射、求值、存储等一系列步骤串联起来进行求值。 JUEL实现了UEL("通用表达式语言")的接口，并扩展出一些类型定义以便能够被更加容易地使用。 JUEL基本框架 1. 表达式工厂（ExpressionFactory/ExpressionFactoryImpl）： UEL整体上使用的是虚拟工厂创建型模...
利用表达式树Expression优化反射性能
design_in_1988的博客
11-12 516
最近做了一个.Net Core环境下，基于NPOI的Excel导入导出以及Word操作的服务封装，涉及到大量反射操作，在性能优化过程中使用到了表达式树，记录一下。 Excel导入是相对比较麻烦的一块，实现的效果是：调用方只需要定义一个类，只需要标记特性，服务读取Excel=>校验(正则、必填、整数范围、日期、数据库是否存在、数据重复) =>将校验结果返回 => 提供方...
在C#中使用Expression代替反射获取动态类中的值
聂绍举的博客
01-20 1258
1
表达式树Expression tree
09-27
C++实现的表达式树。测试的组合有 3 4 + 2 * 2 3 4 * + x x - a b + * x 1 * x 3 + 2 * 3 4 5 * + 3 4 5 ^ + 3 4 5 ^ % 31 x + 42 5 ^ % xcc xc - aa bb + * ...可将上面字符复制到测试文件中，文件名写死在了程序中 ...
FastExpressionCompiler:快速ExpressionTree编译器委托
04-07
FastExpression编译器 针对.NET Standard 2.0、2.1和.NET 4.5 NuGet软件包： FastExpression编译器 源码包：FastExpressionCompiler.src 内部具有公共代码的源：... 但是Expression.Compile()只是很慢
Expression Tree Viewer-开源
04-28
《Expression Tree Viewer 开源项目详解》 在编程领域，数据结构和算法是核心基础，而表达式树（Expression Tree）是一种常用于解析和构建数学、逻辑或其他类型表达式的数据结构。"Expression Tree Viewer" 是一个...
Modular Attention Network for Referring Expression Comprehension——代码阅读第一天
01-06
今天是阅读2018cvpr论文MAttNet源码的第一天，由于第一次读论文源码有很多不懂的地方，在此记录每天的学习进度，希望可以不断提高自身能力。 该论文训练的第一步是准备训练数据，因此先从tools/propro.py开始。...
采用表达式树(Expression Block)对一个对象的属性进行“遍历”
kmguo的专栏
03-03 5799
文章阅读顺序建议： 本系列有一个递进的顺序，可先阅读以下两篇文章： 一、采用Delegate对一个未知类型的对象进行"遍历" http://write.blog.csdn.net/postedit/17392185   二、采用表达式树(Expression Tree)对一个对象的属性进行“遍历” http://write.blog.csdn.net/postedit/19975331
SqlHelper简单实现（通过Expression和反射）1.引言
weixin_30588827的博客
11-28 64
之前老大说要改变代码中充斥着各种Select的Sql语句字符串的情况，让我尝试着做一个简单的SqlHelper，要具有以下功能： 1.不要在业务代码中暴露DataTable或者DataSet类型； 2.可以完成Select操作，需要支持条件查询，分页，单条记录查询，排序，连表，单个值； 3.可以完成添加单条记录，添加多条记录，修改记录和删除记录； 4.使用过程中要兼容老代码，既允许直接传入...
[Flowable6.4.1]DMN报错Error parsing '#{input1 == >19 }': syntax error at position 13, encountered '>'...
weixin_34390105的博客
04-15 2988
2019独角兽企业重金招聘Python工程师标准>>> ...
Expression Tree 表达式树及练习
weixin_30535167的博客
07-05 147
首先认识表达式 所谓的表达式就是一个有意义的式子，如： 3 　　常量值的表达式 num 变量表达式 a+b*2 -a 一元运算符的表达式 Math.Sin(x) + Math.Cos(y) 从上面的例子可以看出，构成表达式的元素有 变量、常量、运算符、函数。表达式通常有一个相应的类型，常量值表达式3的类型是int类型的。 表达式可以组合，如a+b*...
Expression表达式树一些运用
晓剑
08-13 1998
Expression表达式树一些运用 Expression构建有参数有返回值的方法 如下： Expression动态构建的写法： 原文地址：http://www.tnblog.net/aojiancc2/article/details/2533 ...
Java POI 操作excel 无硬编码，反射，史上最牛
javaSamBlog
03-11 256
import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.lang.reflect.Field; import java.lang.re...
C# 表达式目录树Expression
qq_29821795的博客
09-25 772
表达式目录树 表达式目录树：语法树，或者说是一种数据结构 1.表达式目录树Expression：System.Linq.Expressions; 2.描述了多个变量或者和常量之间的关系，按照一定的规则进行组装！ 可以向委托一样使用lambd表达式快捷声明； 不能有语句体，声明只能有一行代码； 可以通过Compile()，编译成一个委托； Func<int, int, int> func = (m, n) => { int i = 0; return m * n + 2;
用C语言建立一个表达式树，仅适用于十进制的加减乘除四则运算，参考结构：typedef struct ExpressionTree{int element;ExpressionTree* left_tree;ExpressionTree* right_tree;}ExpressionTree, *ExpressionTreeRoot;并包含以下数据操作：int evaluate(ExpressionTreeRoot &T);//获得整个表达式树或者相关子树的计算结果；void in_fix( int, bool );//以中缀方式打印表达式；void reverse_polish();//以后缀方式打印表达式；bool is_leaf();//判断节点是否为叶子节点；
最新发布
05-31
root->right_tree->right_tree = (ExpressionTree*)malloc(sizeof(ExpressionTree)); root->right_tree->right_tree->element = 2; printf("Infix expression: "); in_fix(root, true); printf("\n"); ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值