Activator.CreateInstance 方法创建对象和Expression Tree创建对象性能的比较(构造函数含多参数的情况)

Expression Tree 创建任意多个参数的构造函数Lambda表达式

上一篇文章我介绍了使用Expression Tree 来创建带参数的构造函数Lambda表达式，但不是任意多个参数。当天晚上看到Ivony的留言，顿时有了一点灵感，决定再深入一下。

 

固定参数：

上一篇文章只是针对固定参数（例如1个或两个参数的情况）来构建表达式，实际上构建表达式是：

Expression<Func<int, string, object>> createInstanceExp

    = (arg1, arg2) => new Bar(arg1, arg2);

 

使用这个表达式生成的委托并缓存它，性能是很优的。但对于任意多个参数的情况，迫使我把以上表达式丢掉，至少暂时置于一边，而寻求以下表达式——

 

任意多个参数：

Expression<Func<object[], object>> createInstanceExp

    = (args) => new Bar((int)args[0], (string)args[1], ...);

（省略号表示表达式将会是根据args这个参数来动态生成的）

相对于前者，多了一层访问数组以及显式转换，效率明显会低一点，不过应用更广。

下面主要说明怎样建立这个表达式

/// <summary>

/// 创建用来返回构造函数的委托

/// </summary>

/// <param name="type">类型</param>

/// <param name="parameterTypes">构造函数的参数类型数组</param>

/// <returns></returns>

public static Func<object[], object> CreateInstanceDelegate(this Type type, Type[] parameterTypes)

{

    //根据参数类型数组来获取构造函数

    var constructor = type.GetConstructor(parameterTypes);



    //创建lambda表达式的参数

    var lambdaParam = Expression.Parameter(typeof(object[]), "_args");



    //创建构造函数的参数表达式数组

    var constructorParam = buildParameters(parameterTypes, lambdaParam);



    //创建构造函数表达式

    NewExpression newExp = Expression.New(constructor, constructorParam);

    

    //创建lambda表达式，返回构造函数

    Expression<Func<object[], object>> lambdaExp =

        Expression.Lambda<Func<object[], object>>(newExp, lambdaParam);



    return lambdaExp.Compile();

}



/// <summary>

/// 根据类型数组和lambda表达式的参数，转化参数成相应类型 

/// </summary>

/// <param name="parameterTypes">类型数组</param>

/// <param name="paramExp">lambda表达式的参数表达式（参数是：object[]）</param>

/// <returns>构造函数的参数表达式数组</returns>

static Expression[] buildParameters(Type[] parameterTypes, ParameterExpression paramExp)

{

    List<Expression> list = new List<Expression>();

    for (int i = 0; i < parameterTypes.Length; i++)

    {

        //从参数表达式（参数是：object[]）中取出参数

        var arg = BinaryExpression.ArrayIndex(paramExp, Expression.Constant(i));

        //把参数转化成指定类型

        var argCast = Expression.Convert(arg, parameterTypes[i]);



        list.Add(argCast);

    }

    return list.ToArray();

}

 

其实上一篇没有做到的就是创建构造函数的参数表达式这一部分。

BinaryExpression.ArrayIndex(paramExp, Expression.Constant(i)) 是实现取数据元素 args[i] ；

Expression.Convert(arg, parameterTypes[i]) 是实现对 args[i] 进行显式转换；

怎么使用？

Type type = typeof(Bar);

var createInstance1 = type.CreateInstanceDelegate(new Type[] { typeof(int) });

object obj1 = createInstance1(new object[] { 123 });

var createInstance2 = type.CreateInstanceDelegate(new Type[] { typeof(int), typeof(string) });

object obj2 = createInstance2(new object[] { 123, "Bruce" });

 

Oh，No！难看到晕了...

CreateInstanceDelegate 估计只是个裸奔的方法，一般不会直接使用。我给它做件衣服披一下。

/// <summary>

/// 创建实例

/// </summary>

/// <param name="type">类型</param>

/// <param name="args">构造函数的参数列表</param>

/// <returns></returns>

public static object CreateInstance(this Type type, params object[] args)

{

    Func<object[], object> createInstanceDelegate;



    //根据参数列表返回参数类型数组

    var parameterTypes = args.Select(c => c.GetType()).ToArray();



    //从缓存中获取构造函数的委托（注：key是 type 和 parameterTypes）

    if (!cache.TryGetValue(type, parameterTypes, out createInstanceDelegate))

    {

        //缓存中没有找到，新建一个构造函数的委托

        createInstanceDelegate = type.CreateInstanceDelegate(parameterTypes);



        //缓存构造函数的委托

        cache.Add(type, parameterTypes, createInstanceDelegate);

    }

    return createInstanceDelegate(args);

}

（cache是为以上方法专门写的缓存类，但测试结果反映似乎它成了性能的瓶颈，但还好总体速度比Activator.CreateInstance 快，否则就没什么价值可言了）

现在可以直接使用了：

Type type = typeof(Bar);

object obj1 = type.CreateInstance(123);

object obj2 = type.CreateInstance(123, "Bruce");

 

测试代码：

const int count = 500000;



static void Test4()

{

    Console.WriteLine("Test4 - CreateInstance(带n参数): ");



    Stopwatch watcher = new Stopwatch();

    Type type = typeof(Bar);



    watcher.Reset();

    watcher.Start();

    for (int i = 0; i < count; i++)

    {

        Activator.CreateInstance(type, i);

        Activator.CreateInstance(type, i, "string");

    }

    watcher.Stop();

    Console.WriteLine("Activator:  " + watcher.Elapsed);



    watcher.Reset();

    watcher.Start();

    for (int i = 0; i < count; i++)

    {

        type.CreateInstance(i);

        type.CreateInstance(i, "string");

    }

    watcher.Stop();

    Console.WriteLine("Expression(任意): " + watcher.Elapsed);



    watcher.Reset();

    watcher.Start();

    var createInstance1 = type.CreateInstanceDelegate<int>();

    var createInstance2 = type.CreateInstanceDelegate<int, string>();

    for (int i = 0; i < count; i++)

    {

        createInstance1(i);

        createInstance2(i, "string");

    }

    watcher.Stop();

    Console.WriteLine("Expression(固定): " + watcher.Elapsed);



    watcher.Reset();

    watcher.Start();

    for (int i = 0; i < count; i++)

    {

        new Bar(i);

        new Bar(i, "string");

    }

    watcher.Stop();

    Console.WriteLine("Direct:     " + watcher.Elapsed);

    Console.WriteLine();

}

 

测试结果：

Test4 - CreateInstance(带n参数):

Activator:          00:00:02.9804000

Expression(任意): 00:00:01.0157791

Expression(固定): 00:00:00.0178235

Direct:              00:00:00.0045335

（补充一个：如果直接用文中说到的那个裸奔方法，则测试时间是0.03秒左右。所以，如果构建合适的缓存可以提高不少性能）

总结

如何解决对委托进行缓存的问题呢？虽然这已不是本文的范围，但希望能有人继续研究，并实现最优方案。