方法的直接调用，反射调用

想调用一个方法很容易，直接代码调用就行，这人人都会。其次呢，还可以使用反射。不过通过反射调用的性能会远远低于直接调用——至少从绝对时间上来看的确是这样。虽然这是个众所周知的现象，我们还是来写个程序来验证一下。比如我们现在新建一个Console应用程序，编写一个最简单的Call方法。

class Program
{
    static void Main(string[] args)
    {

    }

    public void Call(object o1, object o2, object o3) { }
}

Call方法接受三个object参数却没有任何实现，这样我们就可以让测试专注于方法调用，而并非方法实现本身。于是我们开始编写测试代码，比较一下方法的直接调用与反射调用的性能差距：

static void Main(string[] args)
{
    int times = 1000000;
    Program program = new Program();
    object[] parameters = new object[] { new object(), new object(), new object() };
    program.Call(null, null, null); // force JIT-compile

    Stopwatch watch1 = new Stopwatch();
    watch1.Start();
    for (int i = 0; i < times; i++)
    {
        program.Call(parameters[0], parameters[1], parameters[2]);
    }
    watch1.Stop();
    Console.WriteLine(watch1.Elapsed + " (Directly invoke)");

    MethodInfo methodInfo = typeof(Program).GetMethod("Call");
    Stopwatch watch2 = new Stopwatch();
    watch2.Start();
    for (int i = 0; i < times; i++)
    {
        methodInfo.Invoke(program, parameters);
    }
    watch2.Stop();
    Console.WriteLine(watch2.Elapsed + " (Reflection invoke)");

    Console.WriteLine("Press any key to continue...");
    Console.ReadKey();
}

执行结果如下：

00:00:00.0119041 (Directly invoke)
00:00:04.5527141 (Reflection invoke)
Press any key to continue...

通过各调用一百万次所花时间来看，两者在性能上具有数量级的差距。因此，很多框架在必须利用到反射的场景中，都会设法使用一些较高级的替代方案来改善性能。例如，使用CodeDom生成代码并动态编译，或者使用Emit来直接编写IL。不过自从.NET 3.5发布了Expression相关的新特性，我们在以上的情况下又有了更方便并直观的解决方案。

了解Expression相关特性的朋友可能知道，System.Linq.Expressions.Expression<TDelegate>类型的对象在调用了它了Compile方法之后将得到一个TDelegate类型的委托对象，而调用一个委托对象与直接调用一个方法的性能开销相差无几。那么对于上面的情况，我们又该得到什么样的Delegate对象呢？为了使解决方案足够通用，我们必须将各种签名的方法统一至同样的委托类型中，如下：

public Func<object, object[], object> GetVoidDelegate()
{
    Expression<Action<object, object[]>> exp = (instance, parameters) =>
        ((Program)instance).Call(parameters[0], parameters[1], parameters[2]);

    Action<object, object[]> action = exp.Compile();
    return (instance, parameters) =>
    {
        action(instance, parameters);
        return null;
    };
}

如上，我们就得到了一个Func<object, object[], object>类型的委托，这意味它接受一个object类型与object[]类型的参数，以及返回一个object类型的结果——等等，朋友们有没有发现，这个签名与MethodInfo类型的Invoke方法完全一致？不过可喜可贺的是，我们现在调用这个委托的性能远高于通过反射来调用了。那么对于有返回值的方法呢？那构造一个委托对象就更方便了：

public int Call(object o1, object o2) { return 0; }

public Func<object, object[], object> GetDelegate()
{
    Expression<Func<object, object[], object>> exp = (instance, parameters) =>
        ((Program)instance).Call(parameters[0], parameters[1]);

    return exp.Compile();
}

至此，我想朋友们也已经能够轻松得出调用静态方法的委托构造方式了。可见，这个解决方案的关键在于构造一个合适的Expression<TDelegate>，那么我们现在就来编写一个DynamicExecuter类来作为一个较为完整的解决方案：

public class DynamicMethodExecutor
{
    private Func<object, object[], object> m_execute;

    public DynamicMethodExecutor(MethodInfo methodInfo)
    {
        this.m_execute = this.GetExecuteDelegate(methodInfo);
    }

    public object Execute(object instance, object[] parameters)
    {
        return this.m_execute(instance, parameters);
    }

    private Func<object, object[], object> GetExecuteDelegate(MethodInfo methodInfo)
    {
        // parameters to execute
        ParameterExpression instanceParameter =
            Expression.Parameter(typeof(object), "instance");
        ParameterExpression parametersParameter =
            Expression.Parameter(typeof(object[]), "parameters");

        // build parameter list
        List<Expression> parameterExpressions = new List<Expression>();
        ParameterInfo[] paramInfos = methodInfo.GetParameters();
        for (int i = 0; i < paramInfos.Length; i++)
        {
            // (Ti)parameters[i]
            BinaryExpression valueObj = Expression.ArrayIndex(
                parametersParameter, Expression.Constant(i));
            UnaryExpression valueCast = Expression.Convert(
                valueObj, paramInfos[i].ParameterType);

            parameterExpressions.Add(valueCast);
        }

        // non-instance for static method, or ((TInstance)instance)
        Expression instanceCast = methodInfo.IsStatic ? null :
            Expression.Convert(instanceParameter, methodInfo.ReflectedType);

        // static invoke or ((TInstance)instance).Method
        MethodCallExpression methodCall = Expression.Call(
            instanceCast, methodInfo, parameterExpressions);

        // ((TInstance)instance).Method((T0)parameters[0], (T1)parameters[1], ...)
        if (methodCall.Type == typeof(void))
        {
            Expression<Action<object, object[]>> lambda =
                Expression.Lambda<Action<object, object[]>>(
                    methodCall, instanceParameter, parametersParameter);

            Action<object, object[]> execute = lambda.Compile();
            return (instance, parameters) =>
            {
                execute(instance, parameters);
                return null;
            };
        }
        else
        {
            UnaryExpression castMethodCall = Expression.Convert(
                methodCall, typeof(object));
            Expression<Func<object, object[], object>> lambda =
                Expression.Lambda<Func<object, object[], object>>(
                    castMethodCall, instanceParameter, parametersParameter);

            return lambda.Compile();
        }
    }
}

DynamicMethodExecutor的关键就在于GetExecuteDelegate方法中构造Expression Tree的逻辑。如果您对于一个Expression Tree的结构不太了解的话，不妨尝试一下使用Expression Tree Visualizer来对一个现成的Expression Tree进行观察和分析。我们将一个MethodInfo对象传入DynamicMethodExecutor的构造函数之后，就能将各组不同的实例对象和参数对象数组传入Execute进行执行。这一切就像使用反射来进行调用一般，不过它的性能就有了明显的提高。例如我们添加更多的测试代码：

DynamicMethodExecutor executor = new DynamicMethodExecutor(methodInfo);
Stopwatch watch3 = new Stopwatch();
watch3.Start();
for (int i = 0; i < times; i++)
{
    executor.Execute(program, parameters);
}
watch3.Stop();
Console.WriteLine(watch3.Elapsed + " (Dynamic executor)");

现在的执行结果则是：

00:00:00.0125539 (Directly invoke)
00:00:04.5349626 (Reflection invoke)
00:00:00.0322555 (Dynamic executor)
Press any key to continue...

事实上，Expression<TDelegate>类型的Compile方法正是使用Emit来生成委托对象。不过现在我们已经无需将目光放在更低端的IL上，只要使用高端的API来进行Expression Tree的构造，这无疑是一种进步。不过这种方法也有一定局限性，例如我们只能对公有方法进行调用，并且包含out/ref参数的方法，或者除了方法外的其他类型成员，我们就无法如上例般惬意地编写代码了。

补充

木野狐兄在评论中引用了Code Project的文章《A General Fast Method Invoker》，其中通过Emit构建了FastInvokeHandler委托对象（其签名与Func<object, object[], object>完全相同）的调用效率似乎较“方法直接”调用的性能更高（虽然从原文示例看来并非如此）。事实上FastInvokeHandler其内部实现与DynamicMethodExecutor完全相同，居然有如此令人不可思议的表现实在让人啧啧称奇。我猜测，FastInvokeHandler与DynamicMethodExecutor的性能优势可能体现在以下几个方面：

  1. 范型委托类型的执行性能较非范型委托类型略低（求证）。
  2. 多了一次Execute方法调用，损失部分性能。
  3. 生成的IL代码更为短小紧凑。
  4. 木野狐兄没有使用Release模式编译。:P

不知道是否有对此感兴趣的朋友能够再做一个测试，不过请注意此类性能测试一定需要在Release编译下进行（这点很容易被忽视），否则意义其实不大。

此外，我还想强调的就是，本篇文章进行是纯技术上的比较，并非在引导大家追求点滴性能上的优化。有时候看到一些关于比较for或foreach性能优劣的文章让许多朋友都纠结与此，甚至搞得面红耳赤，我总会觉得有些无可奈何。其实从理论上来说，提高性能的方式有许许多多，记得当时在大学里学习Introduction to Computer System这门课时得一个作业就是为一段C程序作性能优化，当时用到不少手段，例如内联方法调用以减少CPU指令调用次数、调整循环嵌套顺序以提高CPU缓存命中率，将一些代码使用内嵌ASM替换等等，可谓“无所不用其极”，大家都在为几个时钟周期的性能提高而发奋图强欢呼雀跃……

那是理论，是在学习。但是在实际运用中，我们还必须正确对待学到的理论知识。我经常说的一句话是：“任何应用程序都会有其性能瓶颈，只有从性能瓶颈着手才能做到事半功倍的结果。”例如，普通Web应用的性能瓶颈往往在外部IO（尤其是数据库读写），要真正提高性能必须从此入手（例如数据库调优，更好的缓存设计）。正因如此，开发一个高性能的Web应用程序的关键不会在语言或语言运行环境上，.NET、RoR、PHP、Java等等在这一领域都表现良好。

时间： 2024-10-10 00:29:00

方法的直接调用，反射调用的相关文章

利用特性区分查找方法，并通过反射调用方法

如示例代码,buf带描述标记 /// <summary> /// 分析 数据 /// </summary> /// <param name="buf"></param> public void AnalysisDatabuf(string buf) { if (string.IsNullOrEmpty(buf)) return; try { string optNo = buf.Substring(0, 5); string descri

【Java】反射调用与面向对象结合使用产生的惊艳

缘起 我在看Spring的源码时,发现了一个隐藏的问题,就是父类方法(Method)在子类实例上的反射(Reflect)调用. 初次看到,感觉有些奇特,因为父类方法可能是抽象的或私有的,但我没有去怀疑什么,这可是Spring的源码,肯定不会有错. 不过我去做了测试,发现确实是正确的,那一瞬间竟然给我了一丝的惊艳. 这其实是面向对象(继承与重写,即多态)和反射结合的产物.下面先来看测试,最后再进行总结. 友情提示:测试内容较多,不过还是值得一看. 具体方法的继承与重写 先准备一个父类,有三个方法,

C#反射调用程序集类中方法

建立类 class OperatorClass { /// <summary> /// 加法 /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <returns></returns> /// public static int Add(int x, int y) { r

利用反射机制，获取类的字段、方法、并实现简单调用

这篇文章是为之后要介绍Android的ICO框架做预备的,所以,如果想最近学习Android的ICO框架的同学,可以稍微看一下. 首先,简单介绍一下Java里面的反射. JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. 不知道这样的一段解释,你能否看懂.如果更简单的说,反射就是能够根据你给出类名实例化出一个实实在在的对象.所以,对象的实例

java反射调用方法

1:Class类中的方法 public Method getDeclaredMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException 参数: name - 方法名 parameterTypes - 参数数组 返回: 该类与指定名和参数相匹配的方法的 Method 对象 2:Method类中的方法; public Object invoke(Object obj,

跟王老师学反射（六）：使用反射调用方法

跟王老师学反射(六):使用反射调用方法 主讲教师:王少华   QQ群号:483773664 学习内容 使用反射调用方法 当获得某个类对应的Class对象后,就可以通过该Class对象的getMethods()方法或getMethod()方法来获取全部方法或指定方法,这二个方法的返回值是Method对象数组,或者Method对象. 一.public Objectinvoke(Object obj,  Object... args) 获得Method对象后,程序就可以通过该Method来调用对应的方

从vs2010的UnitTestFramework类库提取私有方法反射调用的方法

背景 年龄大点的程序员都知道在vs2010中创建单元测试非常的简单,鼠标定位在方法名字,右键创建单元测试,就会创建一个测试方法,即使是在私有方法上也可以创建测试方法. VS2010以后就没这么简单了,微软默认取消了这种快捷方式,安装  Unit Test Generator 插件也只能在公有方法上创建单元测试.为了方便的测试私有方法,我们需要一种反射调用私有成员的方法.这种现成的方法可以在网上找到不少,我这里是讲述如何从VS2010 的UnitTestFramework类库提取反射调用私有成员的

java动态加载指定的类或者jar包反射调用其方法

序言 有时候,项目中会用到java动态加载指定的类或者jar包反射调用其方法来达到模块的分离,使各个功能之间耦合性大大降低,更加的模块化,代码利用率更高.模式中的代理模式就用到java的这一机制.下边就让我们通过代码来看看如何实现此功能. 代码详细 package loadjarclass; import java.io.File; import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoad

java对过反射调用方法

  public class InvokeTester { public InvokeTester() { } String str; public InvokeTester(String str) { this.str = str; } public int add(int param1, int param2) { return param1 + param2; } public String echo(String msg) { return "echo: " + msg; }

java反射调用某个对象的方法

// 反射调用某个对象的方法 public Object invokeMethod(Object methodObject, String methodName, Object[] args) throws Exception { Class ownerClass = methodObject.getClass(); Class[] argsClass = new Class[args.length]; for (int i = 0, j = args.length; i < j; i++) {