预编译的 lambda 表达式用于创建具有带参数的构造函数的类

Question

我目前正在Activator.CreateInstance创建一个类的实例，其类型作为通用参数传入。问题是，这太慢了。我在某处读到，我可以使用预编译的 lambda 表达式执行相同的操作，但是，在我的情况下，由于需要将参数传递给正在创建的类的实例，因此我在实现此操作时遇到了麻烦。

目前我正在做以下事情

public class Class1
{
    private int TestVariable;

    public Class1(int testVariable)
    {
        TestVariable = testVariable;
    }

    public void TestMethod()
    {
        Console.WriteLine($"Test Variable was {TestVariable}");
    }
}

public object Test<T>(params object[] parameters)
{
    var instance = (T) Activator.CreateInstance(typeof(T), BindingFlags.Instance, null, new object[] {9999}, null);

    var testMethod = typeof(T).GetMethod("TestMethod", BindingFlags.Instance);

    return testMethod.Invoke(instance, parameters)
}

我如何使用预编译的 lambda 表达式完成类似的事情？

Answer 1

实际上，如果您只需要创建一个对象，那么使用Expression.Compile会更慢。但是，如果缓存创建者函数，从长远来看它会更快，因为 lambda 性能会很好。

这是代码：

static Func<TArg, T> CreateCreator<TArg, T>()
{
    var constructor = typeof(T).GetConstructor(new Type[] { typeof(TArg) });
    var parameter = Expression.Parameter(typeof(TArg), "p");
    var creatorExpression = Expression.Lambda<Func<TArg, T>>(
        Expression.New(constructor, new Expression[] { parameter }), parameter);
    return creatorExpression.Compile();
}

Func<TArg, T> creator = CreateCreator<TArg, T>();

有了这个，您可以用于creator(arg)创建 的新对象T。

三种方式的小基准：

class Program
{
    static void Main(string[] args)
    {
        // warm up
        Test1<Class1>(0);
        Test2<int, Class1>(0);

        const int numiter = 10000;
        var sw1 = Stopwatch.StartNew();
        for (int i = 0; i < numiter; i++)
            Test1<Class1>(i);
        sw1.Stop();
        Console.WriteLine($"With Activator.CreateInstance: " +
            $"{(double)sw1.ElapsedTicks / numiter} ticks per object");

        var sw2 = Stopwatch.StartNew();
        for (int i = 0; i < numiter; i++)
            Test2<int, Class1>(i);
        sw2.Stop();

        Console.WriteLine($"With Expression.Compile: " +
            $"{(double)sw2.ElapsedTicks / numiter} ticks per object");

        var sw3 = Stopwatch.StartNew();
        var creator = CreateCreator<int, Class1>();
        for (int i = 0; i < numiter; i++)
            creator(i);
        sw3.Stop();

        Console.WriteLine($"With cached Expression.Compile: " +
            $"{(double)sw3.ElapsedTicks / numiter} ticks per object");
    }

    static public object Test1<T>(params object[] parameters)
    {
        var instance = (T)Activator.CreateInstance(
            typeof(T), BindingFlags.Instance | BindingFlags.Public, null, parameters, null);
        return instance;
    }

    static Func<TArg, T> CreateCreator<TArg, T>()
    {
        var constructor = typeof(T).GetConstructor(new Type[] { typeof(TArg) });
        var parameter = Expression.Parameter(typeof(TArg), "p");
        var creatorExpression = Expression.Lambda<Func<TArg, T>>(
            Expression.New(constructor, new Expression[] { parameter }), parameter);
        return creatorExpression.Compile();
    }

    static public object Test2<TArg, T>(TArg arg)
    {
        var creator = CreateCreator<TArg, T>();
        return creator(arg);
    }
}

在我的机器上产生以下结果（发布模式/Visual Studio 外部）：

static Func<TArg, T> CreateCreator<TArg, T>()
{
    var constructor = typeof(T).GetConstructor(new Type[] { typeof(TArg) });
    var parameter = Expression.Parameter(typeof(TArg), "p");
    var creatorExpression = Expression.Lambda<Func<TArg, T>>(
        Expression.New(constructor, new Expression[] { parameter }), parameter);
    return creatorExpression.Compile();
}