欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

.NET Core开发日志——依赖注入

程序员文章站 2022-07-23 21:06:07
依赖注入(DI)不是一个新的话题,它的出现是伴随着系统解耦的需要而几乎必然产生的。 在SOLID设计原则中,DIP(Dependency inversion principle)——依赖倒置,规定了“需依赖抽象,而非实现”的准则,该原则主要目的是通过引入抽象(比如接口)的方式降低模块之间的耦合性。与 ......

依赖注入(DI)不是一个新的话题,它的出现是伴随着系统解耦的需要而几乎必然产生的。

在SOLID设计原则中,DIP(Dependency inversion principle)——依赖倒置,规定了“需依赖抽象,而非实现”的准则,该原则主要目的是通过引入抽象(比如接口)的方式降低模块之间的耦合性。与此原则相拟而又有所不同的是IoC(inversion of control)——控制反转设计原则。这项原则定义了应该由通用框架而非外部代码决定控制流(control flow)的概念。对控制反转的实现有数种技术,DI(Dependency injection)——依赖注入便是其中之一,而依赖注入技术同时又支持依赖倒置的设计原则,所以它被广泛使用并不是件令人意外的事情。

依赖注入的基本特性是借由一个对象提供对另一对象的依赖。这样的一个对象通常又被称为容器。容器负责被依赖对象的注册(register),解析(resolve)与释放(release),并具有将被依赖对象注入到依赖对象内部的功能。

在之前的ASP.NET开发过程中,要想使用到依赖注入技术必需依赖第三方类库,而在ASP.NET Core中,这项技术已经被引入到其自身的框架中。

容器

ASP.NET Core中使用ServiceProvider作为依赖注入的容器,它是在WebHostBuilder类中被引入的。

public IWebHost Build()
{
    ...

    IServiceProvider GetProviderFromFactory(IServiceCollection collection)
    {
        var provider = collection.BuildServiceProvider();
        var factory = provider.GetService<IServiceProviderFactory<IServiceCollection>>();

        if (factory != null)
        {
            using (provider)
            {
                return factory.CreateServiceProvider(factory.CreateBuilder(collection));
            }
        }

        return provider;
    }
}

注册

所需依赖的对象通过ServiceCollectionServiceExtensions中的各种扩展方法被加入到ServiceCollection类中。ServiceCollection类内部维护着一个ServiceDescriptor集合。而ServiceCollection又会被传入ServiceProvider的构造方法。

public static IServiceCollection AddTransient(
    this IServiceCollection services,
    Type serviceType,
    Type implementationType)
{
    ...

    return Add(services, serviceType, implementationType, ServiceLifetime.Transient);
}

public static IServiceCollection AddScoped(
    this IServiceCollection services,
    Type serviceType,
    Type implementationType)
{
    ...

    return Add(services, serviceType, implementationType, ServiceLifetime.Scoped);
}

public static IServiceCollection AddSingleton(
    this IServiceCollection services,
    Type serviceType,
    Type implementationType)
{
    ...

    return Add(services, serviceType, implementationType, ServiceLifetime.Singleton);
}

private static IServiceCollection Add(
    IServiceCollection collection,
    Type serviceType,
    Type implementationType,
    ServiceLifetime lifetime)
{
    var descriptor = new ServiceDescriptor(serviceType, implementationType, lifetime);
    collection.Add(descriptor);
    return collection;
}

解析

要想获得已注册的对象,可以通过ServiceProviderServiceExtensions类的扩展方法GetService。

public static T GetService<T>(this IServiceProvider provider)
{
    if (provider == null)
    {
        throw new ArgumentNullException(nameof(provider));
    }

    return (T)provider.GetService(typeof(T));
}

ServiceProvider的GetService方法其实是调用了它内部各种引擎的父类ServiceProviderEngine的方法。这些引擎间区别在于实现方式以及性能上,功能方面都是一样的。默认引擎是DynamicServiceProviderEngine。

private readonly IServiceProviderEngine _engine;

internal ServiceProvider(IEnumerable<ServiceDescriptor> serviceDescriptors, ServiceProviderOptions options)
{
  IServiceProviderEngineCallback callback = null;
  if (options.ValidateScopes)
  {
      callback = this;
      _callSiteValidator = new CallSiteValidator();
  }
  switch (options.Mode)
  {
      case ServiceProviderMode.Dynamic:
          _engine = new DynamicServiceProviderEngine(serviceDescriptors, callback);
          break;
      case ServiceProviderMode.Runtime:
          _engine = new RuntimeServiceProviderEngine(serviceDescriptors, callback);
          break;
#if IL_EMIT
      case ServiceProviderMode.ILEmit:
          _engine = new ILEmitServiceProviderEngine(serviceDescriptors, callback);
          break;
#endif
      case ServiceProviderMode.Expressions:
          _engine = new ExpressionsServiceProviderEngine(serviceDescriptors, callback);
          break;
      default:
          throw new NotSupportedException(nameof(options.Mode));
  }
}

public object GetService(Type serviceType) => _engine.GetService(serviceType);

ServiceProviderEngine类的CreateServiceAccessor方法创建了CallSite。

internal object GetService(Type serviceType, ServiceProviderEngineScope serviceProviderEngineScope)
{
    if (_disposed)
    {
        ThrowHelper.ThrowObjectDisposedException();
    }

    var realizedService = RealizedServices.GetOrAdd(serviceType, _createServiceAccessor);
    _callback?.OnResolve(serviceType, serviceProviderEngineScope);
    return realizedService.Invoke(serviceProviderEngineScope);
}

private Func<ServiceProviderEngineScope, object> CreateServiceAccessor(Type serviceType)
{
    var callSite = CallSiteFactory.CreateCallSite(serviceType, new CallSiteChain());
    if (callSite != null)
    {
        _callback?.OnCreate(callSite);
        return RealizeService(callSite);
    }

    return _ => null;
}

假设注册是用的public static IServiceCollection AddSingleton(this IServiceCollection services, Type serviceType, Type implementationType)方法,那么之后的处理会生成一个SingletonCallSite对象并且包含ConstructorCallSite参数值。

private IServiceCallSite TryCreateExact(ServiceDescriptor descriptor, Type serviceType, CallSiteChain callSiteChain)
{
    if (serviceType == descriptor.ServiceType)
    {
        IServiceCallSite callSite;
        if (descriptor.ImplementationInstance != null)
        {
            callSite = new ConstantCallSite(descriptor.ServiceType, descriptor.ImplementationInstance);
        }
        else if (descriptor.ImplementationFactory != null)
        {
            callSite = new FactoryCallSite(descriptor.ServiceType, descriptor.ImplementationFactory);
        }
        else if (descriptor.ImplementationType != null)
        {
            callSite = CreateConstructorCallSite(descriptor.ServiceType, descriptor.ImplementationType, callSiteChain);
        }
        else
        {
            throw new InvalidOperationException("Invalid service descriptor");
        }

        return ApplyLifetime(callSite, descriptor, descriptor.Lifetime);
    }

    return null;
}

private IServiceCallSite CreateConstructorCallSite(Type serviceType, Type implementationType, CallSiteChain callSiteChain)
{
    callSiteChain.Add(serviceType, implementationType);

    var constructors = implementationType.GetTypeInfo()
        .DeclaredConstructors
        .Where(constructor => constructor.IsPublic)
        .ToArray();

    IServiceCallSite[] parameterCallSites = null;

    if (constructors.Length == 0)
    {
        throw new InvalidOperationException(Resources.FormatNoConstructorMatch(implementationType));
    }
    else if (constructors.Length == 1)
    {
        var constructor = constructors[0];
        var parameters = constructor.GetParameters();
        if (parameters.Length == 0)
        {
            return new CreateInstanceCallSite(serviceType, implementationType);
        }

        parameterCallSites = CreateArgumentCallSites(
            serviceType,
            implementationType,
            callSiteChain,
            parameters,
            throwIfCallSiteNotFound: true);

        return new ConstructorCallSite(serviceType, constructor, parameterCallSites);
    }

    ...
}

private IServiceCallSite ApplyLifetime(IServiceCallSite serviceCallSite, object cacheKey, ServiceLifetime descriptorLifetime)
{
    if (serviceCallSite is ConstantCallSite)
    {
        return serviceCallSite;
    }

    switch (descriptorLifetime)
    {
        case ServiceLifetime.Transient:
            return new TransientCallSite(serviceCallSite);
        case ServiceLifetime.Scoped:
            return new ScopedCallSite(serviceCallSite, cacheKey);
        case ServiceLifetime.Singleton:
            return new SingletonCallSite(serviceCallSite, cacheKey);
        default:
            throw new ArgumentOutOfRangeException(nameof(descriptorLifetime));
    }
}

ServiceProvider真正解析的是这个生成出来的CallSite对象。

protected override Func<ServiceProviderEngineScope, object> RealizeService(IServiceCallSite callSite)
{
    var callCount = 0;
    return scope =>
    {
        if (Interlocked.Increment(ref callCount) == 2)
        {
            Task.Run(() => base.RealizeService(callSite));
        }
        return RuntimeResolver.Resolve(callSite, scope);
    };
}

public object Resolve(IServiceCallSite callSite, ServiceProviderEngineScope scope)
{
    return VisitCallSite(callSite, scope);
}

protected virtual TResult VisitCallSite(IServiceCallSite callSite, TArgument argument)
{
    switch (callSite.Kind)
    {
        case CallSiteKind.Factory:
            return VisitFactory((FactoryCallSite)callSite, argument);
        case  CallSiteKind.IEnumerable:
            return VisitIEnumerable((IEnumerableCallSite)callSite, argument);
        case CallSiteKind.Constructor:
            return VisitConstructor((ConstructorCallSite)callSite, argument);
        case CallSiteKind.Transient:
            return VisitTransient((TransientCallSite)callSite, argument);
        case CallSiteKind.Singleton:
            return VisitSingleton((SingletonCallSite)callSite, argument);
        case CallSiteKind.Scope:
            return VisitScoped((ScopedCallSite)callSite, argument);
        case CallSiteKind.Constant:
            return VisitConstant((ConstantCallSite)callSite, argument);
        case CallSiteKind.CreateInstance:
            return VisitCreateInstance((CreateInstanceCallSite)callSite, argument);
        case CallSiteKind.ServiceProvider:
            return VisitServiceProvider((ServiceProviderCallSite)callSite, argument);
        case CallSiteKind.ServiceScopeFactory:
            return VisitServiceScopeFactory((ServiceScopeFactoryCallSite)callSite, argument);
        default:
            throw new NotSupportedException($"Call site type {callSite.GetType()} is not supported");
    }
}

因为上例中CallSite的类型是Constructor,所以最终通过VisitConstructor方法获得所依赖的对象。

protected override object VisitConstructor(ConstructorCallSite constructorCallSite, ServiceProviderEngineScope scope)
{
    object[] parameterValues = new object[constructorCallSite.ParameterCallSites.Length];
    for (var index = 0; index < parameterValues.Length; index++)
    {
        parameterValues[index] = VisitCallSite(constructorCallSite.ParameterCallSites[index], scope);
    }

    try
    {
        return constructorCallSite.ConstructorInfo.Invoke(parameterValues);
    }
    catch (Exception ex) when (ex.InnerException != null)
    {
        ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
        // The above line will always throw, but the compiler requires we throw explicitly.
        throw;
    }
}

至于创建对象的方法是用反射,表达式树(Expression Tree)还是IL Emit,则取决于所使用的内部引擎。

释放

创建ServiceProviderEngine的时候会为其Root属性绑定ServiceProviderEngineScope类型的值,Root = new ServiceProviderEngineScope(this);

在ServiceProviderEngineScope类内部有着用于释放资源的Dispose方法。

public void Dispose()
{
    lock (ResolvedServices)
    {
        if (_disposed)
        {
            return;
        }

        _disposed = true;
        if (_disposables != null)
        {
            for (var i = _disposables.Count - 1; i >= 0; i--)
            {
                var disposable = _disposables[i];
                disposable.Dispose();
            }

            _disposables.Clear();
        }

        ResolvedServices.Clear();
    }
}

internal object CaptureDisposable(object service)
{
    _captureDisposableCallback?.Invoke(service);

    if (!ReferenceEquals(this, service))
    {
        if (service is IDisposable disposable)
        {
            lock (ResolvedServices)
            {
                if (_disposables == null)
                {
                    _disposables = new List<IDisposable>();
                }

                _disposables.Add(disposable);
            }
        }
    }
    return service;
}

并不是所有对象都会通过ServiceProvider容器释放资源,只有容器自己创建的才可以。如果是新建对象再传入容器,容器不会为其作处理。

public void ConfigureServices(IServiceCollection services)
{
    // 容器创建了实例所以会释放它。
    services.AddScoped<Service1>();
    services.AddSingleton<Service2>();
    services.AddSingleton<ISomeService>(sp => new SomeServiceImplementation());

    // 容器没有创建实例所以不会释放它。
    services.AddSingleton<Service3>(new Service3());
    services.AddSingleton(new Service3());
}

注入

ASP.NET Core中最常用的是Constructor Inject(构造器注入)方式。在其MVC框架中,通过DefaultControllerActivator生成Controller时,就可以跟踪到依赖注入是如何被其使用的。

public virtual object Create(ControllerContext controllerContext)
{
    ...

    var serviceProvider = controllerContext.HttpContext.RequestServices;
    return _typeActivatorCache.CreateInstance<object>(serviceProvider, controllerTypeInfo.AsType());
}

DefaultControllerActivator的Create方法使用了TypeActivatorCache类,其内部用到了ActivatorUtilities.CreateFactory方法。

public class TypeActivatorCache : ITypeActivatorCache
{
    private readonly Func<Type, ObjectFactory> _createFactory =
        (type) => ActivatorUtilities.CreateFactory(type, Type.EmptyTypes);
    private readonly ConcurrentDictionary<Type, ObjectFactory> _typeActivatorCache =
           new ConcurrentDictionary<Type, ObjectFactory>();

    public TInstance CreateInstance<TInstance>(
        IServiceProvider serviceProvider,
        Type implementationType)
    {
        ...

        var createFactory = _typeActivatorCache.GetOrAdd(implementationType, _createFactory);
        return (TInstance)createFactory(serviceProvider, arguments: null);
    }
}

ActivatorUtilities类位于ServiceProvider同样的程序集中。

public static ObjectFactory CreateFactory(Type instanceType, Type[] argumentTypes)
{
    FindApplicableConstructor(instanceType, argumentTypes, out ConstructorInfo constructor, out int?[] parameterMap);

    var provider = Expression.Parameter(typeof(IServiceProvider), "provider");
    var argumentArray = Expression.Parameter(typeof(object[]), "argumentArray");
    var factoryExpressionBody = BuildFactoryExpression(constructor, parameterMap, provider, argumentArray);

    var factoryLamda = Expression.Lambda<Func<IServiceProvider, object[], object>>(
        factoryExpressionBody, provider, argumentArray);

    var result = factoryLamda.Compile();
    return result.Invoke;
}

留意BuildFactoryExpression方法中GetServiceInfo变量。

private static Expression BuildFactoryExpression(
    ConstructorInfo constructor,
    int?[] parameterMap,
    Expression serviceProvider,
    Expression factoryArgumentArray)
{
    var constructorParameters = constructor.GetParameters();
    var constructorArguments = new Expression[constructorParameters.Length];

    for (var i = 0; i < constructorParameters.Length; i++)
    {
        var constructorParameter = constructorParameters[i];
        var parameterType = constructorParameter.ParameterType;
        var hasDefaultValue = ParameterDefaultValue.TryGetDefaultValue(constructorParameter, out var defaultValue);

        if (parameterMap[i] != null)
        {
            constructorArguments[i] = Expression.ArrayAccess(factoryArgumentArray, Expression.Constant(parameterMap[i]));
        }
        else
        {
            var parameterTypeExpression = new Expression[] { serviceProvider,
                Expression.Constant(parameterType, typeof(Type)),
                Expression.Constant(constructor.DeclaringType, typeof(Type)),
                Expression.Constant(hasDefaultValue) };
            constructorArguments[i] = Expression.Call(GetServiceInfo, parameterTypeExpression);
        }

        ...
    }

    return Expression.New(constructor, constructorArguments);
}

GetServiceInfo变量申明了对GetService方法的调用,而此GetService其实正是对ServiceProvider的调用。

private static readonly MethodInfo GetServiceInfo =
    GetMethodInfo<Func<IServiceProvider, Type, Type, bool, object>>((sp, t, r, c) => GetService(sp, t, r, c));

private static object GetService(IServiceProvider sp, Type type, Type requiredBy, bool isDefaultParameterRequired)
{
    var service = sp.GetService(type);
    ...
    
    return service;
}

通过以上的处理,在创建Controller时,其构造方法中所需参数的类型也会被容器解析,创建相应实例,从而实现依赖注入功能。

生命周期

ASP.NET Core容器可以创建三种生命周期的对象:

  • Transient, 每次取得的都是新的对象。
  • Scoped, 每次ASP.NET请求生成不同的对象。
  • Singleton,同一对象只会生成一次。

检视这三者类型的构造方法,可以很容易理解Scoped与Singleton是通过缓存的方式实现对象的重用。

public TransientCallSite(IServiceCallSite serviceCallSite)
{
    ServiceCallSite = serviceCallSite;
}

public ScopedCallSite(IServiceCallSite serviceCallSite, object cacheKey)
{
    ServiceCallSite = serviceCallSite;
    CacheKey = cacheKey;
}

public SingletonCallSite(IServiceCallSite serviceCallSite, object cacheKey) : base(serviceCallSite, cacheKey)
{
}

性能

由于ServiceProvider容器使用了反射,表达式树以及IL Emit方式创建对象,可能会对其性能有所担忧,但实际检测的结果,除了Runtime引擎表现不尽如人意外,其它引擎的性能还是在可接受范围内的。

public class GetServiceBenchmark
{
    private const int OperationsPerInvoke = 50000;

    private IServiceProvider _transientSp;
    private ServiceProviderMode _mode;

    [Params("Expressions", "Dynamic", "Runtime", "ILEmit")]
    public string Mode {
        set {
            _mode = (ServiceProviderMode)Enum.Parse(typeof(ServiceProviderMode), value);
        }
    }

    [Benchmark(Baseline = true, OperationsPerInvoke = OperationsPerInvoke)]
    public void NoDI()
    {
        for (int i = 0; i < OperationsPerInvoke; i++)
        {
            var temp = new A(new B(new C()));
            temp.Foo();
        }
    }

    [GlobalSetup(Target = nameof(Transient))]
    public void SetupTransient()
    {
        var services = new ServiceCollection();
        services.AddTransient<A>();
        services.AddTransient<B>();
        services.AddTransient<C>();
        _transientSp = services.BuildServiceProvider(new ServiceProviderOptions()
        {
            Mode = _mode
        });
    }

    [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
    public void Transient()
    {
        for (int i = 0; i < OperationsPerInvoke; i++)
        {
            var temp = _transientSp.GetService<A>();
            temp.Foo();
        }
    }

    private class A
    {
        public A(B b)
        {

        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        public void Foo()
        {

        }
    }

    private class B
    {
        public B(C c)
        {

        }
    }

    private class C
    {

    }
}
// ***** BenchmarkRunner: Finish  *****

// * Export *

// * Detailed results *
GetServiceBenchmark.NoDI: Job-NHLENA(Toolchain=InProcessToolchain, RunStrategy=Throughput) [Mode=Dynamic]
Runtime = ; GC = 
Mean = 5.5175 ns, StdErr = 0.0116 ns (0.21%); N = 15, StdDev = 0.0449 ns
Min = 5.4490 ns, Q1 = 5.4860 ns, Median = 5.5207 ns, Q3 = 5.5641 ns, Max = 5.5972 ns
IQR = 0.0781 ns, LowerFence = 5.3688 ns, UpperFence = 5.6813 ns
ConfidenceInterval = [5.4695 ns; 5.5654 ns] (CI 99.9%), Margin = 0.0480 ns (0.87% of Mean)
Skewness = 0.15, Kurtosis = 1.67


GetServiceBenchmark.Transient: Job-NHLENA(Toolchain=InProcessToolchain, RunStrategy=Throughput) [Mode=Dynamic]
Runtime = ; GC = 
Mean = 43.1601 ns, StdErr = 0.0677 ns (0.16%); N = 15, StdDev = 0.2620 ns
Min = 42.7731 ns, Q1 = 42.9117 ns, Median = 43.2403 ns, Q3 = 43.3580 ns, Max = 43.5392 ns
IQR = 0.4464 ns, LowerFence = 42.2421 ns, UpperFence = 44.0276 ns
ConfidenceInterval = [42.8800 ns; 43.4402 ns] (CI 99.9%), Margin = 0.2801 ns (0.65% of Mean)
Skewness = -0.2, Kurtosis = 1.59


GetServiceBenchmark.NoDI: Job-NHLENA(Toolchain=InProcessToolchain, RunStrategy=Throughput) [Mode=Expressions]
Runtime = ; GC = 
Mean = 5.6964 ns, StdErr = 0.0388 ns (0.68%); N = 33, StdDev = 0.2226 ns
Min = 5.5148 ns, Q1 = 5.5603 ns, Median = 5.6042 ns, Q3 = 5.6769 ns, Max = 6.2460 ns
IQR = 0.1166 ns, LowerFence = 5.3854 ns, UpperFence = 5.8518 ns
ConfidenceInterval = [5.5561 ns; 5.8368 ns] (CI 99.9%), Margin = 0.1404 ns (2.46% of Mean)
Skewness = 1.48, Kurtosis = 3.69


GetServiceBenchmark.Transient: Job-NHLENA(Toolchain=InProcessToolchain, RunStrategy=Throughput) [Mode=Expressions]
Runtime = ; GC = 
Mean = 43.6662 ns, StdErr = 0.0995 ns (0.23%); N = 13, StdDev = 0.3586 ns
Min = 43.1083 ns, Q1 = 43.5089 ns, Median = 43.6051 ns, Q3 = 43.7178 ns, Max = 44.6669 ns
IQR = 0.2089 ns, LowerFence = 43.1956 ns, UpperFence = 44.0311 ns
ConfidenceInterval = [43.2368 ns; 44.0957 ns] (CI 99.9%), Margin = 0.4295 ns (0.98% of Mean)
Skewness = 1.41, Kurtosis = 5.18


GetServiceBenchmark.NoDI: Job-NHLENA(Toolchain=InProcessToolchain, RunStrategy=Throughput) [Mode=ILEmit]
Runtime = ; GC = 
Mean = 5.6016 ns, StdErr = 0.0071 ns (0.13%); N = 13, StdDev = 0.0255 ns
Min = 5.5547 ns, Q1 = 5.5896 ns, Median = 5.5996 ns, Q3 = 5.6226 ns, Max = 5.6400 ns
IQR = 0.0330 ns, LowerFence = 5.5401 ns, UpperFence = 5.6721 ns
ConfidenceInterval = [5.5712 ns; 5.6321 ns] (CI 99.9%), Margin = 0.0305 ns (0.54% of Mean)
Skewness = -0.47, Kurtosis = 2.12


GetServiceBenchmark.Transient: Job-NHLENA(Toolchain=InProcessToolchain, RunStrategy=Throughput) [Mode=ILEmit]
Runtime = ; GC = 
Mean = 43.1397 ns, StdErr = 0.0726 ns (0.17%); N = 15, StdDev = 0.2812 ns
Min = 42.7061 ns, Q1 = 42.9064 ns, Median = 43.1052 ns, Q3 = 43.3093 ns, Max = 43.6443 ns
IQR = 0.4028 ns, LowerFence = 42.3022 ns, UpperFence = 43.9135 ns
ConfidenceInterval = [42.8392 ns; 43.4403 ns] (CI 99.9%), Margin = 0.3006 ns (0.70% of Mean)
Skewness = 0.28, Kurtosis = 1.9


GetServiceBenchmark.NoDI: Job-NHLENA(Toolchain=InProcessToolchain, RunStrategy=Throughput) [Mode=Runtime]
Runtime = ; GC = 
Mean = 6.4814 ns, StdErr = 0.0762 ns (1.18%); N = 100, StdDev = 0.7617 ns
Min = 5.4979 ns, Q1 = 5.8327 ns, Median = 6.3039 ns, Q3 = 6.9775 ns, Max = 8.0420 ns
IQR = 1.1448 ns, LowerFence = 4.1155 ns, UpperFence = 8.6947 ns
ConfidenceInterval = [6.2231 ns; 6.7397 ns] (CI 99.9%), Margin = 0.2583 ns (3.99% of Mean)
Skewness = 0.52, Kurtosis = 1.94


GetServiceBenchmark.Transient: Job-NHLENA(Toolchain=InProcessToolchain, RunStrategy=Throughput) [Mode=Runtime]
Runtime = ; GC = 
Mean = 581.5066 ns, StdErr = 1.6962 ns (0.29%); N = 15, StdDev = 6.5695 ns
Min = 571.4934 ns, Q1 = 576.3829 ns, Median = 580.8121 ns, Q3 = 587.2645 ns, Max = 596.3317 ns
IQR = 10.8816 ns, LowerFence = 560.0605 ns, UpperFence = 603.5869 ns
ConfidenceInterval = [574.4834 ns; 588.5297 ns] (CI 99.9%), Margin = 7.0232 ns (1.21% of Mean)
Skewness = 0.58, Kurtosis = 2.48


Total time: 00:03:11 (191.85 sec)

第三方容器

如果想用第三方容器替换ASP.NET Core原有的容器也是可以办到的。以最常见的Autofac为例,有两种实现方式:

借助ConfigureContainer方法,要先在Program类中挂载AddAutofac方法。

public class Program
{
    public static void Main(string[] args)
    {
        CreateWebHostBuilder(args).Build().Run();
    }

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args).ConfigureServices(services => services.AddAutofac())
            .UseStartup<Startup>();
}

然后在Startup类中加入ConfigureContainer方法。

public void ConfigureContainer(ContainerBuilder builder)
{
    builder.RegisterModule(new DefaultModule());

}

例中的DefaultModule类按照Autofac的通用方式实现。

public class DefaultModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<HelloWorld>().As<IHelloWorld>();
    }
}

如果不想使用ConfigureContainer方法,也可以直接利用ConfigureServices方法:

public IServiceProvider ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    var containerBuilder = new ContainerBuilder();
    containerBuilder.RegisterModule<DefaultModule>();
    containerBuilder.Populate(services);
    var container = containerBuilder.Build();
    return new AutofacServiceProvider(container);
}

需要注意的是,使用这种方式时,ConfigureServices方法的返回类型要从void改成IServiceProvider。