反射 表达式树 DLR 性能,效率 对比

最新推荐文章于 2022-07-07 09:42:05 发布
最新推荐文章于 2022-07-07 09:42:05 发布
阅读量1.4k 收藏
点赞数
分类专栏： C# 表达式树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daonidedie/article/details/41621883
版权

从网上看到了各种反射与表达式树的性能对比.于是自己也写了代码进行测试.发现循环10万次以下时性能相差不大.





<%@ Page Language="C#" AutoEventWireup="true" CodeFile="反射表达式树DLR性能对比.aspx.cs" Inherits="序列反射動態程式集_反射表达式树DLR性能对比" %>

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
    <title>反射表达式树DLR性能对比</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
    
    </div>
    </form>
</body>
</html>








using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class 序列反射動態程式集_反射表达式树DLR性能对比 : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {


        //填充数据
        Action act = () => { InitTypePropertyAssignExpression<TestCalass>(true); };


        Response.Write("转换完成:" + act.StopwatchRun() + "毫秒<br/>");


        List<double> lis = new List<double>() { 0.1,0.5, 10, 20, 30, 50,100,200 };

        //不同循环次数对比
        foreach (double num in lis)
        {

            RunDiff(num);
        }

    }


    #region 填充与计算方法

    Random dom = new Random();
    /// <summary>
    /// 开始比较方法
    /// </summary>
    /// <param name="num">进行多少次比较</param>
    public void RunDiff(double num = 10)
    {
        //10万次计算时间对比
        var arr = System.Linq.Enumerable.Range(1, (int)(num * 10000)).ToList();

        TestCalass c = new TestCalass();

        Action 手动编码 = () =>
        {
            arr.ForEach((o) =>
            {
                
                产生随机值并且填充对像(c, 2);
            });
        };

        Action 表达式树 = () =>
        {
            arr.ForEach((o) =>
            {
                //TestCalass c = new TestCalass();
                产生随机值并且填充对像(c, 0);

            });
        };


        Action 反射 = () =>
        {
            arr.ForEach((o) =>
            {
               // TestCalass c = new TestCalass();
                产生随机值并且填充对像(c, 1);
            });
        };

        long v0, v1, v2;

        Response.Write(string.Format("{0} 运行 {1} 万次,用时{2}毫秒<br/>", "手动编码", arr.Count / 10000.0, v2 = 手动编码.StopwatchRun()));
        Response.Write(string.Format("{0} 运行 {1} 万次,用时{2}毫秒<br/>", "表达式树", arr.Count / 10000.0, v0 = 表达式树.StopwatchRun()));
        Response.Write(string.Format("{0} 运行 {1} 万次,用时{2}毫秒<br/>", "反射赋值", arr.Count / 10000.0, v1 = 反射.StopwatchRun()));
        Response.Write(string.Format("{0}为基准值 {1}用时{2};   {3}用时{4}  相差:{5},快了{6}倍 ", v2, "表达式树", v0-v2, "反射赋值", v1-v2, (v1 - v0),( v1-v0 )/(v0-v2) ));
        Response.Write(string.Format("--------------------------<br/>"));

    }

    /// <summary>
    /// 设置反射数据
    /// </summary>
    public void RefSetvalue(System.Reflection.PropertyInfo p, TestCalass t, object val)
    {
        p.SetValue(t, val, null);
    }

    public void 产生随机值并且填充对像(TestCalass c, int isExpression = 1)
    {
        foreach (var p in exProinfoDic)
        {

            if (p.Value.PropertyType == typeof(int))
            {
                int val = dom.Next(1, int.MaxValue);
                //是否使用表达式赋值
                if (isExpression == 0)
                {
                    //传值
                    p.Value.ActionAssign(val, c);
                    continue;
                }
                if (isExpression == 1)
                {
                    RefSetvalue(p.Value.PropertyInfo, c, val);
                    continue;
                }
                if (isExpression == 2)
                {
                    c.a = val;
                    continue;
                }
            }


            if (p.Value.PropertyType == typeof(string))
            {
                string val = Guid.NewGuid().ToString();
                //是否使用表达式赋值
                if (isExpression == 0)
                {
                    //传值
                    p.Value.ActionAssign(val, c);
                    continue;
                }
                if (isExpression == 1)
                {
                    RefSetvalue(p.Value.PropertyInfo, c, val);
                    continue;
                }
                if (isExpression == 2)
                {
                    c.b = val;
                    continue;
                }
            }

            if (p.Value.PropertyType == typeof(DateTime))
            {
                int vald = dom.Next(1, int.MaxValue);
                DateTime val = DateTime.Now.AddMilliseconds(vald);
                //是否使用表达式赋值
                if (isExpression == 0)
                {
                    //传值
                    p.Value.ActionAssign(val, c);
                    continue;
                }
                if (isExpression == 1)
                {
                    RefSetvalue(p.Value.PropertyInfo, c, val);
                    continue;
                }
                if (isExpression == 2)
                {
                    c.c = val;
                    continue;
                }
            }

            if (p.Value.PropertyType == typeof(double[]))
            {
                double[] val = new double[50];
                for (int i = 0; i < val.Length; i++)
                {
                    val[i] = dom.Next(1, int.MaxValue);
                }
                //是否使用表达式赋值
                if (isExpression == 0)
                {
                    //传值
                    p.Value.ActionAssign(val, c);
                    continue;
                }
                if (isExpression == 1)
                {
                    RefSetvalue(p.Value.PropertyInfo, c, val);
                    continue;
                }
                if (isExpression == 2)
                {
                    c.Arr = val;
                    continue;
                }
            }

        }
    }

    #endregion



    /// <summary>
    /// 初始化类型属性表达式操作,只能处理基元类型
    /// </summary>
    ///<exception cref="System.Collections.Generic.KeyNotFoundException">没有找到合适的处理方法</exception>
    ///<param name="NotFindConvertObject">没有找到合适类型自动转换成为object</param>
    public void InitTypePropertyAssignExpression<T>(bool NotFindConvertObject = false)
    {
        //初始化表达式
        foreach (var p in typeof(T).GetProperties())
        {
            //C# 所有基元类型
            if (CreateExpression<T, byte>(p)) { continue; }
            if (CreateExpression<T, sbyte>(p)) { continue; }
            if (CreateExpression<T, int>(p)) { continue; }
            if (CreateExpression<T, uint>(p)) { continue; }
            if (CreateExpression<T, short>(p)) { continue; }
            if (CreateExpression<T, ushort>(p)) { continue; }
            if (CreateExpression<T, long>(p)) { continue; }
            if (CreateExpression<T, ulong>(p)) { continue; }
            if (CreateExpression<T, float>(p)) { continue; }
            if (CreateExpression<T, double>(p)) { continue; }
            if (CreateExpression<T, char>(p)) { continue; }
            if (CreateExpression<T, bool>(p)) { continue; }
            if (CreateExpression<T, string>(p)) { continue; }
            if (CreateExpression<T, decimal>(p)) { continue; }
            if (CreateExpression<T, object>(p)) { continue; }
            if (CreateExpression<T, DateTime>(p)) { continue; }

            if (NotFindConvertObject)
            {
                //没有找到合适的类型自动转换成为object
                CreateExpression<T, object>(p, true);
            }
            else
            {
                throw new KeyNotFoundException("没有找到合适的基元类型");

            }
        }
    }

    /// <summary>
    /// 创建属性表达式数据实体
    /// </summary>
    /// <typeparam name="T">类型</typeparam>
    /// <typeparam name="TValue">属性的 值类型</typeparam>
    /// <param name="p">属性信息</param>
    /// <param name="toObject">转换成为Object</param>
    /// <returns>成功返回true</returns>
    protected bool CreateExpression<T, TValue>(System.Reflection.PropertyInfo p, bool toObject = false)
    {

        if (p.PropertyType == typeof(TValue) || toObject)
        {
            //添加到缓存集合
            return exProinfoDic.TryAdd(p.Name, new ExpressionPropertyInfo()
             {
                 PropertyType = p.PropertyType,
                 PropertyName = p.Name,
                 PropertyInfo = p,
                 ActionAssign = GetExpression<T, TValue>(p.Name)
             });
        }



        return false;
    }

    /// <summary>
    /// 表达式类型属性信息对像缓存
    /// </summary>
    System.Collections.Concurrent.ConcurrentDictionary<string, ExpressionPropertyInfo> exProinfoDic = new System.Collections.Concurrent.ConcurrentDictionary<string, ExpressionPropertyInfo>();


    /// <summary>
    /// 一个属性传值操作 表达式
    /// </summary>
    /// <param name="propertyName">属性名</param>
    /// <typeparam name="T">实体类型值</typeparam>
    /// <typeparam name="TValue">属性类型值</typeparam>
    /// <returns></returns>
    public Func<TValue, T, TValue> GetExpression<T, TValue>(string propertyName)
    {
        Type t = typeof(T);
        System.Reflection.PropertyInfo pro = t.GetProperty(propertyName);
        return GetExpression<T, TValue>(pro);
    }

    /// <summary>
    /// 一个属性传值操作 表达式
    /// </summary>
    /// <param name="propertyInfo">属性对像</param>
    /// <typeparam name="T">实体类型值</typeparam>
    /// <typeparam name="TValue">属性类型值</typeparam>
    /// <returns></returns>
    public Func<TValue, T, TValue> GetExpression<T, TValue>(System.Reflection.PropertyInfo propertyInfo)
    {
        Type t = typeof(T);
        Type vt = typeof(TValue);
        //参数p
        System.Linq.Expressions.ParameterExpression p = System.Linq.Expressions.Expression.Parameter(t, "p");
        //参数值 v
        System.Linq.Expressions.ParameterExpression v = System.Linq.Expressions.Expression.Parameter(vt, "v");

        //属性 curp
        System.Linq.Expressions.MemberExpression curP = System.Linq.Expressions.Expression.Property(p, propertyInfo);


        //赋值操作
        System.Linq.Expressions.BinaryExpression ass = null;
        if (vt != propertyInfo.PropertyType)
        {
            //转换表达式 v
            System.Linq.Expressions.UnaryExpression conv = System.Linq.Expressions.Expression.Convert(v, propertyInfo.PropertyType);
            //赋值操作
            ass = System.Linq.Expressions.Expression.Assign(curP, conv);

        }
        else
        {
            ass = System.Linq.Expressions.Expression.Assign(curP, v);
        }


        //表达式结果
        System.Linq.Expressions.Expression<Func<TValue, T, TValue>> result = System.Linq.Expressions.Expression.Lambda<Func<TValue, T, TValue>>(ass, v, p);

        //返回编译后结果
        return result.Compile();

    }



    /// <summary>
    /// 表达式类型属性信息对像
    /// </summary>
    public class ExpressionPropertyInfo
    {
        /// <summary>
        /// 属性名
        /// </summary>
        public string PropertyName { get; set; }

        /// <summary>
        /// 属性类型
        /// </summary>
        public Type PropertyType { get; set; }

        /// <summary>
        /// 属性对像
        /// </summary>
        public System.Reflection.PropertyInfo PropertyInfo { get; set; }

        /// <summary>
        /// 赋值操作委托
        /// </summary>
        public dynamic ActionAssign { get; set; }

    }

    /// <summary>
    /// 测试用类
    /// </summary>
    public class TestCalass
    {
        public int a { get; set; }

        public string b { get; set; }

        public DateTime c { get; set; }

        public double[] Arr { get; set; }

    }
}


扩展方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace System
{
    /// <summary>
    /// 通用调试方法
    /// </summary>
    public static class TongTestExpand
    {

        /// <summary>
        /// 测试此方法运行时间
        /// </summary>
        /// <param name="act">运行方法</param>
        /// <returns>返回时间单位毫秒</returns>
        public static long StopwatchRun(this Action act)
        {
            System.Diagnostics.Stopwatch sa = new System.Diagnostics.Stopwatch();
            long result = 0;
            sa.Restart();

            try
            {
                act();
            }
            finally
            {

                sa.Stop();
                result = sa.ElapsedMilliseconds;
            }
            return result;
        }

    }
}


运行结果1(不需要每次创建值)

转换完成:11毫秒
手动编码 运行 0.1 万次,用时7毫秒
表达式树 运行 0.1 万次,用时48毫秒
反射赋值 运行 0.1 万次,用时6毫秒
7为基准值 表达式树用时41; 反射赋值用时-1 相差:-42,快了-1倍 
--------------------------
手动编码 运行 0.5 万次,用时18毫秒
表达式树 运行 0.5 万次,用时22毫秒
反射赋值 运行 0.5 万次,用时33毫秒
18为基准值 表达式树用时4; 反射赋值用时15 相差:11,快了2倍 
--------------------------
手动编码 运行 10 万次,用时403毫秒
表达式树 运行 10 万次,用时445毫秒
反射赋值 运行 10 万次,用时667毫秒
403为基准值 表达式树用时42; 反射赋值用时264 相差:222,快了5倍 
--------------------------
手动编码 运行 20 万次,用时784毫秒
表达式树 运行 20 万次,用时901毫秒
反射赋值 运行 20 万次,用时1348毫秒
784为基准值 表达式树用时117; 反射赋值用时564 相差:447,快了3倍 
--------------------------
手动编码 运行 30 万次,用时1178毫秒
表达式树 运行 30 万次,用时1344毫秒
反射赋值 运行 30 万次,用时2003毫秒
1178为基准值 表达式树用时166; 反射赋值用时825 相差:659,快了3倍 
--------------------------
手动编码 运行 50 万次,用时1987毫秒
表达式树 运行 50 万次,用时2285毫秒
反射赋值 运行 50 万次,用时3396毫秒
1987为基准值 表达式树用时298; 反射赋值用时1409 相差:1111,快了3倍 
--------------------------
手动编码 运行 100 万次,用时4013毫秒
表达式树 运行 100 万次,用时4625毫秒
反射赋值 运行 100 万次,用时6798毫秒
4013为基准值 表达式树用时612; 反射赋值用时2785 相差:2173,快了3倍 
--------------------------
手动编码 运行 200 万次,用时8277毫秒
表达式树 运行 200 万次,用时9281毫秒
反射赋值 运行 200 万次,用时13773毫秒
8277为基准值 表达式树用时1004; 反射赋值用时5496 相差:4492,快了4倍 
--------------------------



运行效果2(在方法中每次创建值)

转换完成:11毫秒
手动编码 运行 0.1 万次,用时7毫秒
表达式树 运行 0.1 万次,用时48毫秒
反射赋值 运行 0.1 万次,用时6毫秒
7为基准值 表达式树用时41; 反射赋值用时-1 相差:-42,快了-1倍 
--------------------------
手动编码 运行 0.5 万次,用时18毫秒
表达式树 运行 0.5 万次,用时22毫秒
反射赋值 运行 0.5 万次,用时33毫秒
18为基准值 表达式树用时4; 反射赋值用时15 相差:11,快了2倍 
--------------------------
手动编码 运行 10 万次,用时403毫秒
表达式树 运行 10 万次,用时445毫秒
反射赋值 运行 10 万次,用时667毫秒
403为基准值 表达式树用时42; 反射赋值用时264 相差:222,快了5倍 
--------------------------
手动编码 运行 20 万次,用时784毫秒
表达式树 运行 20 万次,用时901毫秒
反射赋值 运行 20 万次,用时1348毫秒
784为基准值 表达式树用时117; 反射赋值用时564 相差:447,快了3倍 
--------------------------
手动编码 运行 30 万次,用时1178毫秒
表达式树 运行 30 万次,用时1344毫秒
反射赋值 运行 30 万次,用时2003毫秒
1178为基准值 表达式树用时166; 反射赋值用时825 相差:659,快了3倍 
--------------------------
手动编码 运行 50 万次,用时1987毫秒
表达式树 运行 50 万次,用时2285毫秒
反射赋值 运行 50 万次,用时3396毫秒
1987为基准值 表达式树用时298; 反射赋值用时1409 相差:1111,快了3倍 
--------------------------
手动编码 运行 100 万次,用时4013毫秒
表达式树 运行 100 万次,用时4625毫秒
反射赋值 运行 100 万次,用时6798毫秒
4013为基准值 表达式树用时612; 反射赋值用时2785 相差:2173,快了3倍 
--------------------------
手动编码 运行 200 万次,用时8277毫秒
表达式树 运行 200 万次,用时9281毫秒
反射赋值 运行 200 万次,用时13773毫秒
8277为基准值 表达式树用时1004; 反射赋值用时5496 相差:4492,快了4倍 
--------------------------


和网上(所说的100倍有很大的区别)



生财
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用表达式树提升反射性能
光辉的晨星
09-21 5359
     反射是日常编码中不可或缺的重要特性但是大规模应用又会造成性能问题，因此很多人都写了提升反射速度的辅助类库。在.net1.1时代主要应用Emit自己构造IL，这需要你精通IL而且还不能怕麻烦。而在.net2.0时代由于引入了泛型使我们可以利用泛型委托来减少一部分IL Emit过程（详见这里），但是泛型是编译时确定的而我们更多的应用是在运行时得到或设置对象的属性，及动态执行方法。好在.net
C# 表达式树Expression Trees的知识梳理
08-31
**C# 表达式树 Expression Trees 知识梳理** **1. 表达式树的概念** 表达式树是.NET框架中的一个强大工具，它允许程序员以数据结构的形式表示代码，...理解并熟练掌握表达式树的使用，能显著提升编程的灵活性和效率。
利用表达式树Expression优化反射性能
design_in_1988的博客
11-12 509
最近做了一个.Net Core环境下，基于NPOI的Excel导入导出以及Word操作的服务封装，涉及到大量反射操作，在性能优化过程中使用到了表达式树，记录一下。 Excel导入是相对比较麻烦的一块，实现的效果是：调用方只需要定义一个类，只需要标记特性，服务读取Excel=>校验(正则、必填、整数范围、日期、数据库是否存在、数据重复) =>将校验结果返回 => 提供方...
【反射和表达式树实现调用方法】
maomeideliu的博客
07-07 122
分别用反射和表达式树实现调用方法
反射,Expression Tree,IL Emit 属性操作对比
weixin_30500289的博客
08-18 94
.net的反射（Reflection） 是.Net中获取运行时类型信息的一种方法，通过反射编码的方式可以获得 程序集，模块，类型，元数据等信息。 反射的优点在于微软提供的API调用简单，使用方便； 表达式树（Expression Tree）表达式树以树形数据结构表示代码，其中每一个节点都是一种表达式，表达式树经过编译后生成的直接是IL代码； IL Emit 是直接操作IL的执行过程，对...
表达式树创建对像,反射等性能对比,收集资料
skybot的专栏
11-25 1990
本文主要转自 再谈Activator.CreateInstance(Type type)方法创建对象和Expression Tree创建对象性能的比较(更新版)
LINQ与DLR的Expression tree（4）：创建静态类型的LINQ表达式树节点
03-17
这篇博客文章“LINQ与DLR的Expression tree（4）：创建静态类型的LINQ表达式树节点”深入探讨了如何构建这种数据结构，特别是关注静态类型的表达式树节点。 Expression Tree是一种表示方法调用、条件语句、算术运算...
浅谈.NET反射机制的性能优化 附实例下载
10-28
此外，还可以考虑使用预编译的表达式树（Expression Trees）或IL Emit等方式来进一步提高效率，但这些方法通常更复杂，适用于特定场景。 总的来说，理解并合理使用.NET反射机制的性能优化策略，可以帮助开发者在...
AB设备级环网DLR应用
02-22
AB PLC设备级环网交换机应用案例http://u.download.csdn.net/images/btn_submit.png
表达式树对性能的影响
dhka8040652的博客
09-27 248
至于表达式树是啥我就不想说了,大家可以参考脑袋的相关文章。一至以来，我虽然接触过表达式树，还写过一篇表达式树和泛型委托相关的文章，但终究只现在表面功能，并没有真正认识到它的好处。这两天我看了脑袋的相关文章，每篇都给我们留下了一些练习题，有一道是关于一次性修改实体集中相关属性的问题。 原题：日常应用中我们常常会和一些数据实体类打交道。现在假设我们的数据实体类里面...
用lambda表达式树优化反射
Orbita_wangtao
12-07 527
用lambda表达式树优化反射 本节重点不讲反射机制，而是讲lambda表达式树来替代反射中常用的获取属性和方法，来达到相同的效果但却比反射高效。 每个人都知道，用反射调用一个方法或者对属性执行SetValue和GetValue操作的时候都会比直接调用慢很多，这其中设计到CLR中内部的处理，不做深究。然而，我们在某些情况下又无法不使用反射，比如：在一个ORM框架中，你要将一个DataRow转化...
使用表达式树+反射实现简易ORM对象映射操作
飞权的博客
10-19 893
使用表达式树+反射实现简易ORM对象映射操作为了简单起见我就创建一个文件 BaseDAL.cs , 使用方法也非常简单,看代码吧先创建一个Modelusing System; using System.Collections.Generic; using System.Linq; using System.Text;namespace BaseDAL.Model { [Table("User

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值