推荐一个快速反射调用的类

简介: 本文转载:http://blog.csdn.net/jehnjehn/article/details/7086863   使用传统的.net反射机制,调用类的方法时,在调用频率大的情况下,会感觉速度很慢。

本文转载:http://blog.csdn.net/jehnjehn/article/details/7086863

 

使用传统的.net反射机制,调用类的方法时,在调用频率大的情况下,会感觉速度很慢。最近浏览卢彦的博客时,找到一个他改进后的反射调用类。试用以后感觉效率明显提高,特推荐给大家。作者重新实现了,反射调用方法,但是调用接口和.net原有方法一致。而且调用时抛出的异常为所调用类的实际异常,不像传统方式返回为包装异常。
文章来源:
http://www.codeproject.com/csharp/FastMethodInvoker.asp

快速反射调用类

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;

namespace FastMethodInvoker
{
   
class FastInvoke
   
{
       
publicdelegateobject FastInvokeHandler(object target, object[] paramters);

       
staticobject InvokeMethod(FastInvokeHandler invoke, object target, paramsobject[] paramters)
       
{
           
return invoke(null, paramters);
        }


       
publicstatic FastInvokeHandler GetMethodInvoker(MethodInfo methodInfo)
       
{
            DynamicMethod dynamicMethod
=new DynamicMethod(string.Empty, typeof(object), new Type[] { typeof(object), typeof(object[]) }, methodInfo.DeclaringType.Module);
            ILGenerator il
= dynamicMethod.GetILGenerator();
            ParameterInfo[] ps
= methodInfo.GetParameters();
            Type[] paramTypes
=new Type[ps.Length];
           
for (int i =0; i < paramTypes.Length; i++)
           
{
               
if (ps[i].ParameterType.IsByRef)
                    paramTypes[i]
= ps[i].ParameterType.GetElementType();
               
else
                    paramTypes[i]
= ps[i].ParameterType;
            }

            LocalBuilder[] locals
=new LocalBuilder[paramTypes.Length];

           
for (int i =0; i < paramTypes.Length; i++)
           
{
                locals[i]
= il.DeclareLocal(paramTypes[i], true);
            }

           
for (int i =0; i < paramTypes.Length; i++)
           
{
                il.Emit(OpCodes.Ldarg_1);
                EmitFastInt(il, i);
                il.Emit(OpCodes.Ldelem_Ref);
                EmitCastToReference(il, paramTypes[i]);
                il.Emit(OpCodes.Stloc, locals[i]);
            }

           
if (!methodInfo.IsStatic)
           
{
                il.Emit(OpCodes.Ldarg_0);
            }

           
for (int i =0; i < paramTypes.Length; i++)
           
{
               
if (ps[i].ParameterType.IsByRef)
                    il.Emit(OpCodes.Ldloca_S, locals[i]);
               
else
                    il.Emit(OpCodes.Ldloc, locals[i]);
            }

           
if (methodInfo.IsStatic)
                il.EmitCall(OpCodes.Call, methodInfo,
null);
           
else
                il.EmitCall(OpCodes.Callvirt, methodInfo,
null);
           
if (methodInfo.ReturnType ==typeof(void))
                il.Emit(OpCodes.Ldnull);
           
else
                EmitBoxIfNeeded(il, methodInfo.ReturnType);

           
for (int i =0; i < paramTypes.Length; i++)
           
{
               
if (ps[i].ParameterType.IsByRef)
               
{
                    il.Emit(OpCodes.Ldarg_1);
                    EmitFastInt(il, i);
                    il.Emit(OpCodes.Ldloc, locals[i]);
                   
if (locals[i].LocalType.IsValueType)
                        il.Emit(OpCodes.Box, locals[i].LocalType);
                    il.Emit(OpCodes.Stelem_Ref);
                }

            }


            il.Emit(OpCodes.Ret);
            FastInvokeHandler invoder
= (FastInvokeHandler)dynamicMethod.CreateDelegate(typeof(FastInvokeHandler));
           
return invoder;
        }


       
privatestaticvoid EmitCastToReference(ILGenerator il, System.Type type)
       
{
           
if (type.IsValueType)
           
{
                il.Emit(OpCodes.Unbox_Any, type);
            }

           
else
           
{
                il.Emit(OpCodes.Castclass, type);
            }

        }


       
privatestaticvoid EmitBoxIfNeeded(ILGenerator il, System.Type type)
       
{
           
if (type.IsValueType)
           
{
                il.Emit(OpCodes.Box, type);
            }

        }


       
privatestaticvoid EmitFastInt(ILGenerator il, int value)
       
{
           
switch (value)
           
{
               
case-1:
                    il.Emit(OpCodes.Ldc_I4_M1);
                   
return;
               
case0:
                    il.Emit(OpCodes.Ldc_I4_0);
                   
return;
               
case1:
                    il.Emit(OpCodes.Ldc_I4_1);
                   
return;
               
case2:
                    il.Emit(OpCodes.Ldc_I4_2);
                   
return;
               
case3:
                    il.Emit(OpCodes.Ldc_I4_3);
                   
return;
               
case4:
                    il.Emit(OpCodes.Ldc_I4_4);
                   
return;
               
case5:
                    il.Emit(OpCodes.Ldc_I4_5);
                   
return;
               
case6:
                    il.Emit(OpCodes.Ldc_I4_6);
                   
return;
               
case7:
                    il.Emit(OpCodes.Ldc_I4_7);
                   
return;
               
case8:
                    il.Emit(OpCodes.Ldc_I4_8);
                   
return;
            }


           
if (value >-129&& value <128)
           
{
                il.Emit(OpCodes.Ldc_I4_S, (SByte)value);
            }

           
else
           
{
                il.Emit(OpCodes.Ldc_I4, value);
            }

        }

    }

}


效果测试程序

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;

namespace FastMethodInvoker
{
   
class Program
   
{
       
staticvoid Main(string[] args)
       
{

            Type t
=typeof(Person);
            MethodInfo methodInfo
= t.GetMethod("Say");
            Person person
=new Person();
           
string word ="hello";
            Person p
=null;
           
object[] param =newobject[] { word, p, 3 };
           
int TestTimes =100000; //测试次数,可自行调节看效果

           
#region 传统方式反射
           
try
           
{
                Stopwatch watch
=new Stopwatch();
                watch.Start();
               
for (int i =0; i < TestTimes; i++)
               
{
                    methodInfo.Invoke(person, param);
                }

                watch.Stop();
                Console.WriteLine(TestTimes.ToString()
+" times invoked by Reflection: "+ watch.ElapsedMilliseconds +"ms");
            }

           
catch (System.Exception ex)
           
{
                Console.WriteLine(
"传统方式反射 直接错误:"+ ex.Message);
                Console.WriteLine(
"传统方式反射 内部错误:"+ ex.InnerException.Message);
            }

           
#endregion


           
#region 快速反射
           
try
           
{
                Stopwatch watch1
=new Stopwatch();
                FastInvoke.FastInvokeHandler fastInvoker
= FastInvoke.GetMethodInvoker(methodInfo);
                watch1.Start();
               
for (int i =0; i < TestTimes; i++)
               
{
                    fastInvoker(person, param);
                }

                watch1.Stop();
                Console.WriteLine(TestTimes.ToString()
+" times invoked by FastInvoke: "+ watch1.ElapsedMilliseconds +"ms");
            }

           
catch (System.Exception ex)
           
{
                Console.WriteLine(
"快速反射 错误:"+ ex.Message);
            }

           
#endregion


           
#region 直接调用
           
try
           
{
                Stopwatch watch2
=new Stopwatch();
                watch2.Start();
               
for (int i =0; i < TestTimes; i++)
               
{
                    person.Say(
ref word, out p, 3);
                }

                watch2.Stop();
                Console.WriteLine(TestTimes.ToString()
+" times invoked by DirectCall: "+ watch2.ElapsedMilliseconds +"ms");
            }

           
catch (System.Exception ex)
           
{
                Console.WriteLine(
"直接调用 错误:"+ ex.Message);
            }

           
#endregion

           
            Console.ReadLine();
        }

    }


   
publicclass Person
   
{
       
publicvoid Say(refstring word, out Person p, int avi)
       
{
            word
="ttt"+ avi.ToString();
            p
=new Person();

           
//throw new System.Exception("出错了哦");
        }

    }

}

目录
相关文章
|
4天前
|
存储 关系型数据库 分布式数据库
PostgreSQL 18 发布,快来 PolarDB 尝鲜!
PostgreSQL 18 发布,PolarDB for PostgreSQL 全面兼容。新版本支持异步I/O、UUIDv7、虚拟生成列、逻辑复制增强及OAuth认证,显著提升性能与安全。PolarDB-PG 18 支持存算分离架构,融合海量弹性存储与极致计算性能,搭配丰富插件生态,为企业提供高效、稳定、灵活的云数据库解决方案,助力企业数字化转型如虎添翼!
|
15天前
|
弹性计算 关系型数据库 微服务
基于 Docker 与 Kubernetes(K3s)的微服务:阿里云生产环境扩容实践
在微服务架构中,如何实现“稳定扩容”与“成本可控”是企业面临的核心挑战。本文结合 Python FastAPI 微服务实战,详解如何基于阿里云基础设施,利用 Docker 封装服务、K3s 实现容器编排,构建生产级微服务架构。内容涵盖容器构建、集群部署、自动扩缩容、可观测性等关键环节,适配阿里云资源特性与服务生态,助力企业打造低成本、高可靠、易扩展的微服务解决方案。
1312 5
|
2天前
|
监控 JavaScript Java
基于大模型技术的反欺诈知识问答系统
随着互联网与金融科技发展,网络欺诈频发,构建高效反欺诈平台成为迫切需求。本文基于Java、Vue.js、Spring Boot与MySQL技术,设计实现集欺诈识别、宣传教育、用户互动于一体的反欺诈系统,提升公众防范意识,助力企业合规与用户权益保护。
|
14天前
|
机器学习/深度学习 人工智能 前端开发
通义DeepResearch全面开源!同步分享可落地的高阶Agent构建方法论
通义研究团队开源发布通义 DeepResearch —— 首个在性能上可与 OpenAI DeepResearch 相媲美、并在多项权威基准测试中取得领先表现的全开源 Web Agent。
1356 87
|
2天前
|
JavaScript Java 大数据
基于JavaWeb的销售管理系统设计系统
本系统基于Java、MySQL、Spring Boot与Vue.js技术,构建高效、可扩展的销售管理平台,实现客户、订单、数据可视化等全流程自动化管理,提升企业运营效率与决策能力。
|
3天前
|
弹性计算 安全 数据安全/隐私保护
2025年阿里云域名备案流程(新手图文详细流程)
本文图文详解阿里云账号注册、服务器租赁、域名购买及备案全流程,涵盖企业实名认证、信息模板创建、域名备案提交与管局审核等关键步骤,助您快速完成网站上线前的准备工作。
192 82
2025年阿里云域名备案流程(新手图文详细流程)