经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » ASP.net » 查看文章
详解.NET依赖注入中对象的创建与“销毁”
来源：cnblogs　　作者：寻己Tenleft　　时间：2023/10/16 16:07:36　　对本文有异议

在DI容器中注册类型，DI容器就可以帮我们创建类型的实例；如果注册类型实现了IAsyncDisposable或者IDisposable接口，对象销毁时DI容器还会帮我们调用DisposeAsync或Dispose方法。这是如何实现的呢？一起来看看吧。本文是基于Dependency Injection 8.0编写。如果已熟练使用，可以直接从第三节开始观看。

功能演示

说明：对象的销毁由GC管理，这里的“销毁”是指调用Dispose方法。

先介绍一下DI容器中类的三种生命周期：Singleton(单例)、Scoped(在每个ServiceProviderEngineScope中只创建一次，可以理解为局部单例)、Transient(每次都创建新对象)。
先定义三个代表生命周期的接口ISingletonService、IScopedService和ITransientService；分别在实现类中打印创建信息和Dispose信息。并且在打印信息里添加了HashCode，可以观察是哪个对象被创建和“销毁”。代码在每个Scope中对每个不同生命周期的类创建2个对象，共12次调用，来看看实际上一共创建了几个对象。

  1. public interface ISingletonService { }
  2. public interface IScopedService{ }
  3. public interface ITransientService { }
  5. public class SingletonService : ISingletonService, IDisposable
  6. {
  7.     public SingletonService()
  8.     {
  9.         Console.WriteLine($"{this.GetType()} 被创建了 - {this.GetHashCode()}...");
  10.     }
  11.     public void Dispose()
  12.     {
  13.         Console.WriteLine($"{this.GetType()} 被销毁了- {this.GetHashCode()}...");
  14.     }
  15. }

可以看到，Singleton对象创建了1个，Scoped对象创建了2个（因为有两个ServiceProviderEngineScope）,Transient对象每次调用都会创建新的对象，共4个。
Dispose方法调用顺序是，先创建的最后调用。

ASP.NET CORE中Scope

在ASP.NET CORE中每次请求会创建一个Scope，通过HttpContext.RequestServices可以获取这个Scope对象，所以生命周期为Scoped的类在一次请求中只会创建一次，局部单例。

  1. // HttpContext.RequestServices
  2. public override IServiceProvider RequestServices
  3. {
  4.     get { return ServiceProvidersFeature.RequestServices; }
  5.     set { ServiceProvidersFeature.RequestServices = value; }
  6. }
  7. public class RequestServicesFeature
  8. {
  9.     public IServiceProvider RequestServices
  10.     {
  11.         get
  12.         {
  13.             if (!_requestServicesSet && _scopeFactory != null)
  14.             {
  15.                 _context.Response.RegisterForDisposeAsync(this);
  16.                 //每次请求创建一个Scope
  17.                 _scope = _scopeFactory.CreateScope();
  18.                 _requestServices = _scope.ServiceProvider;
  19.                 _requestServicesSet = true;
  20.             }
  21.             return _requestServices!;
  22.         }
  23.         set
  24.         {
  25.             _requestServices = value;
  26.             _requestServicesSet = true;
  27.         }
  28.     }
  29. }

深入理解

要理解对象的创建和“销毁”，ServiceProvider类是关键。
ServiceProvider创建和“销毁”对象主要是通过它的两个成员来完成的；分别是ServiceProviderEngine _engine和ServiceProviderEngineScope Root

  • ServiceProviderEngine这是一个抽象类，只有一个方法RealizeService，该方法返回一个创建实例的委托。该类不直接创建对象，而是提供一个创建对象的委托！
  • ServiceProviderEngineScope又可以分两类，根scope和子scope，它们的主要功能是：
    捕获创建的对象存入List<object>? _disposables中，用于调用Dispose方法。

ServiceProviderEngine

通过类型信息创建实例主要有三种办法 1.反射，2.表达式树，3.Emit。这些功能实现在ServiceProviderEngine的子类中，继承关系如下：

  • ServiceProviderEngine
    • RuntimeServiceProviderEngine 反射
    • ExpressionsServiceProviderEngine 表达式树
    • ILEmitServiceProviderEngine Emit
    • CompiledServiceProviderEngine 表达式树和Emit的组合
      • DynamicServiceProviderEngine 默认用的这个Engine，实现方式有点难理解

下面看一下这些类的实现

  1. internal sealed class ExpressionsServiceProviderEngine : ServiceProviderEngine
  2. {
  3.     //使用这个类构建表达式树
  4.     private readonly ExpressionResolverBuilder _expressionResolverBuilder;
  5.     //返回一个创建对象的委托！
  6.     public override Func<ServiceProviderEngineScope, object> RealizeService(ServiceCallSite callSite)
  7.     {
  8.         return _expressionResolverBuilder.Build(callSite);
  9.     }
  10. }
  11. internal sealed class ILEmitServiceProviderEngine : ServiceProviderEngine
  12. {
  13.     //使用这个类构建emit
  14.     private readonly ILEmitResolverBuilder _expressionResolverBuilder;
  15.     public override Func<ServiceProviderEngineScope, object?> RealizeService(ServiceCallSite callSite)
  16.     {
  17.         return _expressionResolverBuilder.Build(callSite);
  18.     }
  19. }
  20. internal sealed class RuntimeServiceProviderEngine : ServiceProviderEngine
  21. {   // 反射
  22.     public static RuntimeServiceProviderEngine Instance { get; } = new RuntimeServiceProviderEngine();
  23.     //使用反射相关方法在CallSiteRuntimeResolver中
  24.     public override Func<ServiceProviderEngineScope, object?> RealizeService(ServiceCallSite callSite)
  25.     {
  26.         return scope => CallSiteRuntimeResolver.Instance.Resolve(callSite, scope);
  27.     }
  28. }
  29. internal abstract class CompiledServiceProviderEngine : ServiceProviderEngine
  30. {
  31.     //通过以下方式选择默认创建实例的方式
  32. #if IL_EMIT
  33.     public ILEmitResolverBuilder ResolverBuilder { get; } //emit构建
  34. #else
  35.     public ExpressionResolverBuilder ResolverBuilder { get; } //表达式树构建
  36. #endif
  38.     public CompiledServiceProviderEngine(ServiceProvider provider)
  39.     {
  40.         ResolverBuilder = new(provider);
  41.     }
  43.     public override Func<ServiceProviderEngineScope, object?> RealizeService(ServiceCallSite callSite) => ResolverBuilder.Build(callSite);
  44. }

默认是使用emit的方式创建对象，通过以下方法可以验证默认使用的引擎和创建实例的方式

  1. static void EngineInfo(ServiceProvider provider)
  2. {
  3.     var p = Expression.Parameter(typeof(ServiceProvider));
  4.     //相当于 provider._engine
  5.     var lambda = Expression.Lambda<Func<ServiceProvider, object>>(Expression.Field(p, "_engine"), p);
  7.     var engine = lambda.Compile()(provider);
  8.     var baseType = engine.GetType().BaseType!;
  9.     // 相当于(provider._engine as CompiledServiceProviderEngine).ResolverBuilder
  10.     var lambda2 = Expression.Lambda<Func<ServiceProvider, object>>(
  11.         Expression.Property(Expression.Convert(Expression.Field(p, "_engine"), baseType), "ResolverBuilder"), p);
  13.     var builder = lambda2.Compile()(provider);
  14.     Console.WriteLine(engine.GetType());
  15.     Console.WriteLine(builder.GetType());
  16.     //输出信息:
  17.     //Microsoft.Extensions.DependencyInjection.ServiceLookup.DynamicServiceProviderEngine
  18.     //Microsoft.Extensions.DependencyInjection.ServiceLookup.ILEmitResolverBuilder
  19. }

从上面输出可以看到DynamicServiceProviderEngine是默认的Engine，并且它的父类CompiledServiceProviderEngine是使用的ILEmitResolverBuilder。
下面来介绍DynamicServiceProviderEngine，这段代码三年前看不懂，我三年后还是不太懂，实现方式有点难以理解，有大佬懂的可以解答下。
首先，Singleton对象是不会调用这个方法的，只有生命周期是Scoped和Transient才会调用这个方法。通过调用RealizeService获取一个创建对象的委托；对于每一个服务标识，在调用2次后，替换为用emit的方式去创建实例的委托（如果不理解服务标识，看我的这篇文章），并且，还是用线程池实现的，对于Web开发，而CPU绑定的异步不推荐使用线程池。
前几次调用，反射性能应该是优于emit和表达式树，因为后两者有一个构建委托的过程。但是，使用线程池的影响应该远大于前者吧。一开始就直接使用emit创建对象不应该优于使用线程池？上百个类使用线程池，会导致网站启动时很卡。当然，也就启动后一小段时间卡。

  1. internal sealed class DynamicServiceProviderEngine : CompiledServiceProviderEngine
  2. {
  3.     public override Func<ServiceProviderEngineScope, object?> RealizeService(ServiceCallSite callSite)
  4.     {
  5.         int callCount = 0;
  6.         return scope =>
  7.         {
  8.             // Resolve the result before we increment the call count, this ensures that singletons
  9.             // won't cause any side effects during the compilation of the resolve function.
  10.             var result = CallSiteRuntimeResolver.Instance.Resolve(callSite, scope);
  11.             if (Interlocked.Increment(ref callCount) == 2)
  12.             {
  13.                 //不捕获ExecutionContext，AsyncLocal失效。
  14.                 _ = ThreadPool.UnsafeQueueUserWorkItem(_ =>
  15.                 {
  16.                     _serviceProvider.ReplaceServiceAccessor(callSite, base.RealizeService(callSite));
  17.                 },
  18.                 null);
  19.             }
  20.             return result;
  21.         };
  22.     }
  23. }

获取创建对象的委托时，需要传入参数ServiceCallSite，callSite对象有类型的创建信息，指明如何创建这个类型的实例，比如通过构造函数、工厂、创建数组（IEnumerable<>服务）、常量等创建实例。并且在后面调用创建对象的委托时，如果需要缓存，会把创建出来的对象缓存到callSite对象中。

ServiceProviderEngineScope

下面再来介绍下ServiceProviderEngineScope，主要成员及相关介绍在下面代码中。
如何创建ServiceProviderEngineScope对象呢？通过services.CreateScope()就是创建一个scope对象。创建scope对象时，会传递ServiceProvider并保存到RootProvider属性中。而每个scope对象又有一个名字为ServiceProvider的属性，它的值是this；所以scope.ServiceProvider == scope。
我们发现这个对象也有GetService方法，发现它只是转发了一下，其实还是调用ServiceProvider的GetService获取对象。这个方法还把当前scope作为参数传递过去了，表示创建出来的对象由当前scope对象管理。
我们通过scope.ServiceProvider.GetService<ISingletonService>()获取对象和services.GetService<ISingletonService>()基本一样，只是传递的scope不同，前者是传递自己，后者是传递ServiceProvider对象中的scope对象（也就是Root属性）。
再次说明：scope.ServiceProvider是返回自己，scope.RootProvider才是真正的ServiceProvider对象

  1. internal sealed class ServiceProviderEngineScope : IServiceScope, IServiceProvider, IKeyedServiceProvider, IAsyncDisposable, IServiceScopeFactory
  2. {
  3.     //缓存创建出来的对象，只会缓存“非根Scope”创建的且生命周期为“Scoped”的实例
  4.     internal Dictionary<ServiceCacheKey, object?> ResolvedServices { get; }
  5.     // 存放捕获的 disposables 对象
  6.     private List<object>? _disposables;
  7.     //是否为根Scope
  8.     public bool IsRootScope { get; }
  9.     //这里有点绕，ServiceProvider属性返回的是自己。每个子Scope就是 engineScope
  10.     public IServiceProvider ServiceProvider => this;
  11.     //RootProvider属性是保存的ServiceProvider对象
  12.     internal ServiceProvider RootProvider { get; }
  13.     //所有创建Scope的方法都是调用 ServiceProvider的CreateScope方法
  14.     public IServiceScope CreateScope() => RootProvider.CreateScope();
  15.     //唯一构造函数
  16.     public ServiceProviderEngineScope(ServiceProvider provider, bool isRootScope)
  17.     {
  18.         ResolvedServices = new Dictionary<ServiceCacheKey, object?>();
  19.         RootProvider = provider; //保存ServiceProvider对象
  20.         IsRootScope = isRootScope;//只有ServiceProvider对象中的scope对象的这个值是true，其它都是false
  21.     }
  22.     public object? GetService(Type serviceType)
  23.     {
  24.         //每个子scope还是调用RootProvider创建服务，只是由子scope捕获对象用于释放Dispose
  25.         return RootProvider.GetService(ServiceIdentifier.FromServiceType(serviceType), this);
  26.     }
  27. }

在ServiceProvider的构造函数中，注册了IServiceProvider和IServiceScopeFactory服务。两者都是返回一个ServiceProviderEngineScope对象，前者是返回当前scope对象，后者是返回单例根scope对象（Root属性）。这是理解创建scope对象流程的前提。

调用services.CreateScope() 创建scope对象流程：

  • 1.调用ServiceProvider的CreateScope方法。services.CreateScope()
  • 2.CreateScope方法就是获取根scope并调用它自己的CreateScope方法。provider.GetRequiredService<IServiceScopeFactory>().CreateScope()
  • 3.而根scope的CreateScope方法是调用ServiceProvider的CreateScope方法。RootProvider.CreateScope()
  • 4.在ServiceProvider的CreateScope方法中就是new一个对象。new ServiceProviderEngineScope(this, isRootScope: false)

兜兜转转，services.CreateScope()最终是调用自己内部方法CreateScope。代码和注释已贴出，结合上下两段代码看。

  1. //这是在ServiceProvider的构造函数中注册的服务
  2. CallSiteFactory.Add(ServiceIdentifier.FromServiceType(typeof(IServiceProvider)), new ServiceProviderCallSite());
  3. CallSiteFactory.Add(ServiceIdentifier.FromServiceType(typeof(IServiceScopeFactory)), new ConstantCallSite(typeof(IServiceScopeFactory), Root));
  5. //我们创建Scope是调用的这个扩展方法，结合上面代码，你会发现CreateScope其实是调用的自己的同名方法
  6. public static IServiceScope CreateScope(this IServiceProvider provider)
  7. {
  8.     return provider.GetRequiredService<IServiceScopeFactory>().CreateScope();
  9. }
  10. //这里是ServiceProvider的CreateScope方法，它“internal”修饰的，但最终调用的这里
  11. internal IServiceScope CreateScope()
  12. {
  13.     // 创建Scope最终是调用的这里，ServiceProvider会保存在每个Scope里，每个Scope都是同一个ServiceProvider
  14.     return new ServiceProviderEngineScope(this, isRootScope: false);
  15. }

根scope和子scope

根scope和子scope通过IsRootScope属性区分，保存在ServiceProvider中的Root属性就是一个根scope，其生命周期是全局的，程序停止才会调用Dispose方法。ASP.NET CORE中每次请求创建的scope就是一个子scope。通过两个例子加深印象：

  1. static void EngineScopeTest()
  2. {
  3.     using var services = new ServiceCollection().BuildServiceProvider();
  4.     using var scope1 = services.CreateScope();
  5.     using var scope2 = scope1.ServiceProvider.CreateScope();
  6.     //返回当前scope
  7.     var rootScope = services.GetService<IServiceProvider>();
  8.     //返回根scope
  9.     var rootScope2 = services.GetService<IServiceScopeFactory>();
  11.     var currentScope = scope1.ServiceProvider.GetService<IServiceProvider>();
  12.     var rootScope3 = scope1.ServiceProvider.GetService<IServiceScopeFactory>();
  14.     var currentScope2 = scope2.ServiceProvider.GetService<IServiceProvider>();
  15.     var rootScope4 = scope2.ServiceProvider.GetService<IServiceScopeFactory>();
  16.     // 获取根scope
  17.     var root = GetRoot(services);
  18.     //运行代码输出4个 True
  19.     Console.WriteLine(rootScope == root && rootScope == (root as IServiceScope)!.ServiceProvider);
  20.     Console.WriteLine(rootScope == rootScope3 && rootScope == rootScope4);
  21.     Console.WriteLine(currentScope == scope1 && currentScope == scope1.ServiceProvider);
  22.     Console.WriteLine(currentScope2 == scope2 && currentScope2 == scope2.ServiceProvider);
  23. }
  24. static object GetRoot(ServiceProvider provider)
  25. {   //通过表达式树获取根scope
  26.     var p = Expression.Parameter(typeof(ServiceProvider));
  27.     //相当于 provider.Root
  28.     var lambda = Expression.Lambda<Func<ServiceProvider, object>>(Expression.Property(p, "Root"), p);
  29.     return lambda.Compile()(provider);
  30. }

调用GetService<IServiceProvider>()返回的是当前scope，调用GetService<IServiceScopeFactory>()返回的是根scope。就算通过子scope方法scope1.ServiceProvider.CreateScope()创建scope，最终还是调用new ServiceProviderEngineScope(this, isRootScope: false)创建scope，并且子scope之间没有层级关系，每个子scope都保存了同一份ServiceProvider对象。
再通过以下例子验证一下，子scope是否真的保存了ServiceProvider对象

  1. static void EngineScopeWhitServiceProviderTest()
  2. {
  3.     using var services = new ServiceCollection().BuildServiceProvider();
  4.     using var scope1 = services.CreateScope()!;
  5.     using var scope2 = scope1.ServiceProvider.CreateScope()!;
  7.     var rootScope = services.GetService<IServiceProvider>();
  9.     var currentScope = scope1.ServiceProvider.GetService<IServiceProvider>();
  11.     var currentScope2 = scope2.ServiceProvider.GetService<IServiceProvider>();
  13.     var provider = GetRootProvider(scope1);//获取子scope保存的ServiceProvider
  14.     var provider2 = GetRootProvider(scope2);//获取子scope保存的ServiceProvider
  15.     //获取根scope的ServiceProvider
  16.     var root = (IServiceScope)GetRoot(services);
  17.     var provider3 = GetRootProvider(root);
  19.     Console.WriteLine(services == provider && services == provider2 && services == provider3);
  20.     Console.WriteLine(services != rootScope && services != currentScope && services != root.ServiceProvider);
  21. }
  23. static object GetRootProvider(IServiceScope scope)
  24. {   //通过表达式树获取RootProvider
  25.     var p = Expression.Parameter(typeof(IServiceScope));
  26.     //相当于 scope.RootProvider
  27.     var lambda = Expression.Lambda<Func<IServiceScope, object>>(
  28.        Expression.Property(Expression.Convert(p, scope.GetType()), "RootProvider"), p);
  29.     return lambda.Compile()(scope);
  30. }

验证没问题。根scope和子scope的几个特点：

  • 都会捕获需要释放Dispose的对象
  • 所有Singleton对象的“销毁”由根scope管理
  • 对于Scoped和Transient的对象，谁关联谁管理（创建对象时需要传入一个关联scope对象）
    • 注意：对于Scoped和Transient的对象被ServiceProvider创建时，它们的生命周期就变成了Singleton，它们的Dispose方法往往需要等程序停止时才会调用。虽然可以在创建容器时设置参数ValidateScopes开启校验，但只会校验Scoped对象，它只会禁止ServiceProvider中创建Scoped对象和Singleton对象中注入Scoped对象，对于Transient对象不会校验，所以Transient对象的Dispose方法要等程序停止时才会调用。
  • 子scope会缓存生命周期为“Scoped”的实例，并保存到ResolvedServices属性中。
    • 虽然后面会把创建对象的委托替换成了Emit的形式，但是生命周期为“Scoped”的实例已经保存到ResolvedServices属性中，所以后面创建的“Scoped”的实例还是同一个。
  • 对于根scope关联的Singleton和Scoped对象，创建出来后都会缓存，只是保存在不同地方(创建对象的委托中或ServiceCallSite中)。

问：子scope创建的Singleton对象是由根scope管理的，那子scope是怎样获取根scope对象的呢？
答：前面讲过，子scope会保存ServiceProvider对象，访问它的Root属性就可以得到根scope。像这样scope1.RootProvider.Root。这两个成员的修饰符都是internal，我们要想访问，可以参考前面的代码GetRootProvider和GetRoot

Dispose

对象被DI容器创建出来，如果有实现Dispose接口，就会被ServiceProviderEngineScope捕获并放入对象List<object>? _disposables中，并在DI容器本身被调用Dispose方法时，会逆序调用_disposables中每个对象的Dispose方法( for (int i = _disposables.Count - 1; i >= 0; i--))，也就是调用scope的Dispose方法就会调用它捕获对象的Dispose方法。

scope的Dispose方法调用的时机：

  • 对于根scope，也就是ServiceProvider的Root属性，当ServiceProvider的Dispose方法被调用时，会调用Root.Dispose()
  • 对于子scope需要自己手动调用Dispose方法或者用using。

通过一段代码来验证一下scope对象是否真的捕获了对象：

  1. static void DisposeTest()
  2. {
  3.     using var services = new ServiceCollection()
  4.          .AddSingleton<ISingletonService, SingletonService2>()
  5.          .AddScoped<IScopedService, ScopedService2>()
  6.          .AddTransient<ITransientService, TransientService2>()
  7.          .BuildServiceProvider();
  8.     
  9.     var singleton1 = services.GetService<ISingletonService>();
  10.     var scoped1 = services.GetService<IScopedService>();
  11.     var transient1 = services.GetService<ITransientService>();
  12.     //获取被捕获的对象
  13.     var rootDisposables = GetRootDisposables(services);
  15.     Console.WriteLine(rootDisposables.Any(o => o == singleton1)
  16.         && rootDisposables.Any(o => o == scoped1)
  17.         && rootDisposables.Any(o => o == transient1)
  18.         && rootDisposables.Count == 3);
  20.     using (var scope1 = services.CreateScope())
  21.     {
  22.         var singleton2 = scope1.ServiceProvider.GetService<ISingletonService>();
  23.         var scoped2 = scope1.ServiceProvider.GetService<IScopedService>();
  24.         var transient2 = scope1.ServiceProvider.GetService<ITransientService>();
  26.         var singleton3 = scope1.ServiceProvider.GetService<ISingletonService>();
  27.         var scoped3 = scope1.ServiceProvider.GetService<IScopedService>();
  28.         var transient3 = scope1.ServiceProvider.GetService<ITransientService>();
  29.         //获取被捕获的对象
  30.         var scopeDisposables = GetScopeDisposables(scope1.ServiceProvider);
  31.         //Singleton保存在Root Scope中
  32.         Console.WriteLine(scopeDisposables.Any(o => o == singleton2) == false
  33.             && scopeDisposables.Any(o => o == singleton3) == false
  34.             && scopeDisposables.Count == 3);//2个Transient对象，1个Scope对象
  36.         Console.WriteLine(scopeDisposables.Any(o => o == scoped2)
  37.             && scopeDisposables.Any(o => o == transient2)
  38.             && scopeDisposables.Any(o => o == scoped3)
  39.             && scopeDisposables.Any(o => o == transient3));
  40.     }
  41. }
  42. static List<object> GetRootDisposables(ServiceProvider provider)
  43. {
  44.     var providerParam = Expression.Parameter(typeof(ServiceProvider));
  45.     // provider.Root
  46.     var engineParam = Expression.Property(providerParam, "Root");
  47.     // provider.Root._disposables;
  48.     var dispoParam = Expression.Field(engineParam, "_disposables");
  49.     var lambda = Expression.Lambda<Func<ServiceProvider, List<object>>>(dispoParam, providerParam);
  51.     return lambda.Compile()(provider);
  52. }
  53. static List<object> GetScopeDisposables(IServiceProvider provider)
  54. {
  55.     //这个provider就是ServiceProviderEngineScope
  56.     var providerParam = Expression.Parameter(typeof(IServiceProvider));
  57.     // provider as ServiceProviderEngineScope
  58.     var engineParam = Expression.Convert(providerParam, provider.GetType());
  59.     // (provider as ServiceProviderEngineScope)._disposables;
  60.     var dispoParam = Expression.Field(engineParam, "_disposables");
  61.     var lambda = Expression.Lambda<Func<IServiceProvider, List<object>>>(dispoParam, providerParam);
  63.     return lambda.Compile()(provider);
  64. }

输出3个True，没问题。

ServiceProvider

最后再介绍一下，ServiceProvider是如何利用ServiceProviderEngineScope和ServiceProviderEngine创建和管理对象的。类ServiceIdentifier是DI8.0的新功能

  1. private sealed class ServiceAccessor
  2. {
  3.     //类型的创建信息和缓存
  4.     public ServiceCallSite? CallSite { get; set; }
  5.     //来自ServiceProviderEngine的RealizeService方法
  6.     public Func<ServiceProviderEngineScope, object?>? RealizedService { get; set; }
  7. }
  8. //注意，RealizeService方法的参数和返回值就是ServiceAccessor类的成员
  9. internal sealed class ILEmitServiceProviderEngine : ServiceProviderEngine
  10. {
  11.     public override Func<ServiceProviderEngineScope, object?> RealizeService(ServiceCallSite callSite)
  12.     {
  13.        //...
  14.     }
  15. }
  16.  public sealed class ServiceProvider : IServiceProvider, IKeyedServiceProvider, IDisposable, IAsyncDisposable
  17.  {
  18.      //伪代码，但最终是new DynamicServiceProviderEngine
  19.      internal ServiceProviderEngine _engine = new DynamicServiceProviderEngine(this);
  20.      //根scope 它的IsRootScope属性为true
  21.      internal ServiceProviderEngineScope Root { get; }
  23.     //我们获取服务最终都是调用这里
  24.     internal object? GetService(ServiceIdentifier serviceIdentifier, ServiceProviderEngineScope serviceProviderEngineScope)
  25.     {
  26.         //_serviceAccessors是一个字典，可以理解为每一个服务标识对应一个创建对象的创建对象的委托
  27.         ServiceAccessor serviceAccessor = _serviceAccessors.GetOrAdd(serviceIdentifier, CreateServiceAccessor);
  28.         //调用 委托 获取对象
  29.         object? result = serviceAccessor.RealizedService?.Invoke(serviceProviderEngineScope);
  31.         return result;
  32.     }
  34.     private ServiceAccessor CreateServiceAccessor(ServiceIdentifier serviceIdentifier)
  35.     {
  36.         //GetCallSite方法获取类型的创建信息，指明如何创建这个类型的实例，比如通过构造函数、工厂、创建数组（IEnumerable<>服务）、常量等创建实例
  37.         ServiceCallSite? callSite = CallSiteFactory.GetCallSite(serviceIdentifier, new CallSiteChain());
  39.         if (callSite.Cache.Location == CallSiteResultCacheLocation.Root)
  40.         {
  41.             //Singleton对象，通过反射创建一次
  42.             object? value = CallSiteRuntimeResolver.Instance.Resolve(callSite, Root);
  43.             //Resolve方法里，在对象创建出来后会保存到callSite里面，如果实现dispose接口还会被Root捕获
  44.             return new ServiceAccessor { CallSite = callSite, RealizedService = scope => value };
  45.         }
  46.         //调用 ServiceProviderEngine 获取一个 创建对象的委托
  47.         Func<ServiceProviderEngineScope, object?> realizedService = _engine.RealizeService(callSite);
  48.         return new ServiceAccessor { CallSite = callSite, RealizedService = realizedService };
  49.     }
  50. }

代码只保留了核心逻辑。创建对象时，所有的GetService方法最终都是调用这个方法GetService(ServiceIdentifier serviceIdentifier, ServiceProviderEngineScope serviceProviderEngineScope)。该方法接收一个“服务标识”和一个“ServiceProviderEngineScope”对象，如果是通过services.GetService调用，传递的就是根scope；如果是通过scope1.ServiceProvider.GetService调用，传递的就是当前子scope对象。
GetService方法先通过CreateServiceAccessor获取“服务标识”相关信息(ServiceCallSite)和创建对象的委托。ServiceCallSite前面有介绍。Singleton对象不会通过ServiceProviderEngine的RealizeService方法获取创建对象的委托，而是直接通过反射创建对象并缓存起来。Scoped和Transient对象通过 _engine.RealizeService(callSite)获取创建对象的委托。最后就是调用委托获取对象。

总结

.NET依赖注入中获取对象就是通过GetService方法，方法内容主要就两步：

  • 1.获取创建对象的委托（通过ServiceProviderEngine）
  • 2.调用委托创建对象

如果创建出来的对象实现了IAsyncDisposable或者IDisposable接口,创建出来的对象会被ServiceProviderEngineScope捕获用于调用Dispose方法。
如有疑问，欢迎评论交流。如有错误，欢迎批评指出。
写文章是真累！以后尽量多写文章，这样也能放在简历上了。

最后，我好像失业了，从上个月15号投简历到现在已经一个月了，就几个面试。磨练心态中......有没有大佬招人，技术牛逼的公司，我少拿工资也心甘情愿。

原文链接：https://www.cnblogs.com/tenleft/p/17766501.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

ASP.net热门文章

  • 【Dotnet 工具箱】WPF UI - 现代化设计的开源 WPF 框架
  • net core 使用 SqlSugar
  • .NETCore下CI/CD之自动化测试
  • .net core部署到linux可能碰到的问题
  • Abp vNext 自定义 Ef Core 仓储引发异常
  • .NetCore 消息队列的使用
  • .NetCore WebApi——基于JWT的简单身份认证与授权（Swagger）
  • Abp.NHibernate连接PostgreSQl数据库
  • ModelValidator基于元数据的验证
  • .NET MAUI 安卓应用开发初体验

    • ASP.net推荐文章

  • Gradio.NET 支持 .NET 8 简化 Web 应用开发
  • .NET 轻量化定时任务调度 FreeScheduler
  • WPF 模仿前端大佬写一个Hover效果
  • WPF 模拟UWP原生窗口样式——亚克力|云母材质、自定义标题栏样式、原生DWM动画 （附我封装好的类）
  • .NET 音频采集
  • .NET8 Blazor 从入门到精通：（三）类库和表单
  • wpf 如何7步写一个badge控件
  • .NET 高效Nuget管理工具（开源）
  • .NET 8 跨平台高性能边缘采集网关
  • .NET 窗口/屏幕录制

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号