主页 / 问题 / 715920
Accepted
Kunoichi
Asked:2020-09-08 17:50:33 +0000 UTC2020-09-08 17:50:33 +0000 UTC

在 C# 中创建对象的方法

  • 772

我知道在 C# 中创建对象的一种方法：

public static class ObjectCreator
{
    public static T GetObject<T>() where T : class
    {
        return (T)Activator.CreateInstance(typeof(T));
    }
}

有没有更高产的？

用已知方式更新类：

 public class ObjectCreator<T> where T: new()
{
    protected Func<T> V4Lambda;

    protected Func<T> V5Lambda;

    public ObjectCreator()
    {
        Type sType = typeof(T);

        //V4
        V4Lambda = Expression.Lambda<Func<T>>(Expression.New(sType)).Compile();

        //V5
        V5Lambda = DynamicModuleLambdaCompiler.GenerateFactory<T>();
    }

    public T V1()
    {
        return (T)Activator.CreateInstance(typeof(T));
    }

    public T V2()
    {
        return new T();
    }

    public T V3()
    {
        return CustomActivator.CreateInstance<T>();
    }

    public T V4()
    {
        return V4Lambda();
    }

    public T V5()
    {
        return V5Lambda();
    }
}

public static class CustomActivator
{
    public static T CreateInstance<T>() where T : new()
    {
        return ActivatorImpl<T>.Factory();
    }

    private class ActivatorImpl<T> where T : new()
    {
        private static readonly Expression<Func<T>> _expr = () => new T();

        public static readonly Func<T> Factory = _expr.Compile();
    }
}

public static class DynamicModuleLambdaCompiler
{
    public static Func<T> GenerateFactory<T>() where T : new()
    {
        Expression<Func<T>> expr = () => new T();
        NewExpression newExpr = (NewExpression)expr.Body;

        var method = new DynamicMethod(
            name: "lambda",
            returnType: newExpr.Type,
            parameterTypes: new Type[0],
            m: typeof(DynamicModuleLambdaCompiler).Module,
            skipVisibility: true);

        ILGenerator ilGen = method.GetILGenerator();
        // Constructor for value types could be null
        if (newExpr.Constructor != null)
        {
            ilGen.Emit(OpCodes.Newobj, newExpr.Constructor);
        }
        else
        {
            LocalBuilder temp = ilGen.DeclareLocal(newExpr.Type);
            ilGen.Emit(OpCodes.Ldloca, temp);
            ilGen.Emit(OpCodes.Initobj, newExpr.Type);
            ilGen.Emit(OpCodes.Ldloc, temp);
        }

        ilGen.Emit(OpCodes.Ret);

        return (Func<T>)method.CreateDelegate(typeof(Func<T>));
    }
}

我的测试结果：

在此处输入图像描述

c#

2 个回答

  1. Best Answer

    在 Sergei Teplyakov 的以下文章中

    它得出的结论是，创建对象的最快方法是将 lambda 解析为表达式并编译它：

    public static class DynamicModuleLambdaCompiler
{
    public static Func<T> GenerateFactory<T>() where T:new()
    {
        Expression<Func<T>> expr = () => new T();
        NewExpression newExpr = (NewExpression)expr.Body;

        var method = new DynamicMethod(
            name: "lambda", 
            returnType: newExpr.Type,
            parameterTypes: new Type[0],
            m: typeof(DynamicModuleLambdaCompiler).Module,
            skipVisibility: true);

        ILGenerator ilGen = method.GetILGenerator();
        // Constructor for value types could be null
        if (newExpr.Constructor != null)
        {
            ilGen.Emit(OpCodes.Newobj, newExpr.Constructor);
        }
        else
        {
            LocalBuilder temp = ilGen.DeclareLocal(newExpr.Type);
            ilGen.Emit(OpCodes.Ldloca, temp);
            ilGen.Emit(OpCodes.Initobj, newExpr.Type);
            ilGen.Emit(OpCodes.Ldloc, temp);
        }

        ilGen.Emit(OpCodes.Ret);

        return (Func<T>)method.CreateDelegate(typeof(Func<T>));
    }
}

    public static class FastActivator<T> where T : new()
{
    /// <summary>
    /// Extremely fast generic factory method that returns an instance
    /// of the type <typeparam name="T"/>.
    /// </summary>
    public static readonly Func<T> Create =
        DynamicModuleLambdaCompiler.GenerateFactory<T>();
}

                      Method |       Mean |    StdDev |  Gen 0 |
------------------------ |----------- |---------- |------- |
 ActivatorCreateInstance | 95.0161 ns | 1.0861 ns | 0.0005 |
        FuncBasedFactory |  6.5741 ns | 0.0608 ns | 0.0034 |
  FastActivator_T_Create |  5.1715 ns | 0.0466 ns | 0.0034 |
    • 9

  2. 您几乎不应该进行低级微优化。（因为编译器迟早会优化得更好。）

    但是如果在某些地方你真的需要优化，那么只需将创建函数传递到Func<T>你需要的地方就足够了，就是这样：

    public class ObjectCreator<Т>
{
    Func<T> create;
    public ObjectCreator(Func<T> create) => this.create = create;
    public T GetObject() => create();
}

    你会失去一些抽象，但你应该去，而不是跳棋？这是最快的方法。

    在正确的地方调用正确的构造函数会更快。因为调用代表不是免费的。另一方面，如果您需要纳米优化，那么您选择了错误的平台。

    基准：

    BenchmarkDotNet=v0.10.9, OS=Windows 7 SP1 (6.1.7601)
Processor=Intel Core i7-2600K CPU 3.40GHz (Sandy Bridge), ProcessorCount=8
Frequency=3320429 Hz, Resolution=301.1659 ns, Timer=TSC
  [Host]     : .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.2053.0
  DefaultJob : .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.2053.0


                                         Method |      Mean |     Error |    StdDev |
----------------------------------------------- |----------:|----------:|----------:|
                    V1_Activator_CreateInstance | 70.639 ns | 0.3354 ns | 0.3138 ns |
                        V2_NewGenericConstraint | 77.813 ns | 0.2788 ns | 0.2608 ns |
              V3_CustomActivator_CreateInstance | 20.237 ns | 0.0562 ns | 0.0498 ns |
                          V4_Expression_Compile | 11.175 ns | 0.1693 ns | 0.1584 ns |
 V5_DynamicModuleLambdaCompiler_GenerateFactory |  4.822 ns | 0.0322 ns | 0.0301 ns |
                                V6_Factory_Func |  3.967 ns | 0.0247 ns | 0.0231 ns |
                     V7_Direct_Constructor_Call |  3.047 ns | 0.0207 ns | 0.0194 ns |
    • 6

相关问题