ASP.NET Core - 依赖注入(三)

4.  容器中的服务创建与释放

我们使用了 IoC 容器之后，服务实例的创建和销毁的工作就交给了容器去处理，前面也讲到了服务的生命周期，那三种生命周期中对象的创建和销毁分别在什么时候呢。以下面的例子演示以下：
首先是新增三个类，用于注册三种不同的生命周期：

1. public class Service1
2. {
3.     public Service1()
4.     {
5.         Console.WriteLine("Service1 Created");
6.     }
7. }
8. public class Service2
9. {
10.     public Service2()
11.     {
12.         Console.WriteLine("Service2 Created");
13.     }
14. }
15. public class Service3
16. {
17.     public Service3()
18.     {
19.         Console.WriteLine("Service3 Created");
20.     }
21. }

复制代码

接下来是演示场景，为了简单起见，就用后台服务程序吧

1. IHost host = Host.CreateDefaultBuilder(args)
2.     .ConfigureServices(services =>
3.     {
4.         services.AddHostedService<Worker>();
5.         services.AddSingleton<Service1>();
6.         services.AddScoped<Service2>();
7.         services.AddTransient<Service3>();
8.     })
9.     .Build();
11. await host.RunAsync();
13. public class Worker : BackgroundService
14. {
15.     private readonly ILogger<Worker> _logger;
16.     private readonly IServiceProvider _serviceProvid
17.     public Worker(ILogger<Worker> logger, IServiceProvider serviceProvider)
18.     {
19.         _logger = logger;
20.         _serviceProvider = serviceProvider;
21.     }
23.     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
24.     {
25.         #region 生命周期实例创建
26.         Console.WriteLine("Service1 第一次调用");
27.         var service11 = _serviceProvider.GetService<Service1>();
28.         Console.WriteLine("Service1 第二次调用");
29.         var service12 = _serviceProvider.GetService<Service1>();
31.         // 创建作用域，与 Web 应用中的一次请求一样
32.         using (var scope = _serviceProvider.CreateScope())
33.         {
34.             Console.WriteLine("Service2 第一次调用");
35.             var service31 = scope.ServiceProvider.GetService<Service2>();
36.             Console.WriteLine("Service2 第二次调用");
37.             var service32 = scope.ServiceProvider.GetService<Service2>();
39.             using (var scope1 = _serviceProvider.CreateScope())
40.             {
41.                 Console.WriteLine("Service2 第三次调用");
42.                 var service33 = scope1.ServiceProvider.GetService<Service2>();
43.             }
44.         }
45.         {
46.             Console.WriteLine("Service3 第一次调用");
47.             var service41 = _serviceProvider.GetService<Service3>();
49.             Console.WriteLine("Service3 第二次调用");
50.             var service42 = _serviceProvider.GetService<Service3>();
51.             }
52.             #endregion
53.         }
54.     }
55. }

复制代码

最终的输出如下：

通过输出，我们可以单例生命周期服务在第一次使用的时候创建，之后一直是一个实例，作用域生命周期服务在一个作用域中第一次使用的时候创建实例，之后在同一个实例中只保持一个，但在其他作用域中则会重新创建，而瞬时生命周期服务每次都会创建一个新实例。
看完创建，我们再看实例销毁的时机。
若服务实现了IDisposable接口，并且该服务是由DI容器创建的，则我们不应该手动去Dispose，DI容器会对服务自动进行释放。这里由两个关键点，一个是要实现 Idisposable 接口，一个是由容器创建。这里再增加多两个类，用于演示，并且为了避免干扰将之前演示创建过程的代码注释。

1. public class Service1 : IDisposable
2. {
3.     public Service1()
4.     {
5.         Console.WriteLine("Service1 Created");
6.   
7.     public void Dispose()
8.     {
9.         Console.WriteLine("Service1 Dispose");
10.     }
11. }
13. public class Service2 : IDisposable
14. {
15.     public Service2()
16.     {
17.         Console.WriteLine("Service2 Created");
19.     public void Dispose()
20.     {
21.         Console.WriteLine("Service2 Dispose");
22.     }
23. }
25. public class Service3 : IDisposable
26. {
27.     public Service3()
28.     {
29.         Console.WriteLine("Service3 Created");
30.     }
32.     public void Dispose()
33.     {
34.         Console.WriteLine("Service3 Dispose");
35.     }
36. }
38. public class Service4 : IDisposable
39. {
40.     public void Dispose()
41.     {
42.         Console.WriteLine("Service4 Dispose");
43.     }
44. }
46. public class Service5 : IDisposable
47. {
48.     public void Dispose()
49.     {
50.         Console.WriteLine("Service5 Dispose");
51.     }
52. }

复制代码

之后后台服务程序也做一些修改

1. IHost host = Host.CreateDefaultBuilder(args)
2.     .ConfigureServices(services =>
3.     {
4.         services.AddHostedService<Worker>();
5.         services.AddSingleton<Service1>();
6.         services.AddScoped<Service2>();
7.         services.AddTransient<Service3>();
8.         // 这种方式依旧由容器创建实例，只不过提供了工厂方法
9.         services.AddSingleton<Service4>(provider => new Service4());
10.         // 这种方式是用外部创建实例，只有单例生命周期可用
11.         services.AddSingleton<Service5>(new Service5());
12.     })
13.     .Build();
15. await host.RunAsync();
17. public class Worker : BackgroundService
18. {
19.     private readonly ILogger<Worker> _logger;
20.     private readonly IServiceProvider _serviceProvid
21.     public Worker(ILogger<Worker> logger, IServiceProvider serviceProvider)
22.     {
23.         _logger = logger;
24.         _serviceProvider = serviceProvider;
25.     }
27.     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
28.     {
29.         #region 生命周期实
30.         Console.WriteLine("Service1 调用");
31.         var service1 = _serviceProvider.GetService<Service1>();
33.         // 创建作用域，与 Web 应用中的一次请求一样
34.         using (var scope = _serviceProvider.CreateScope())
35.         {
36.             Console.WriteLine("Service2 调用");
37.             var service2 = scope.ServiceProvider.GetService<Service2>();
38.             Console.WriteLine("即将结束作用域
39.             Console.WriteLine("Service3 调用");
40.             var service3 = scope.ServiceProvider.GetService<Service3>();
41.         }
43.         Console.WriteLine("Service4 调用");
44.         var service4 = _serviceProvider.GetService<Service4>();
45.         Console.WriteLine("Service5 调用");
46.         var service5 = _serviceProvider.GetService<Service5>();
48.         #endregion
49.     }
50. }

复制代码

这样要直接用命令启动应用，不能够通过vs调试，之后Ctrl+C停止应用的时候，输出如下：

通过输出可以看得到，瞬时生命周期服务和作用域生命周期服务在超出作用范围就会被释放，而单例生命周期服务则在应用关闭时才释放，同为单例生命周期的Service5没有被释放。
这里要提一下的是，在解析瞬时生命周期服务Service3的时候，示例代码中是放到一个单独的作用域中的，这是因为在通过 services.AddHostedService(); 注入Worker的时候是注入为单例生命周期的，而在单例生命周期对象中解析其他生命周期的对象是会有问题的，这也是服务注入、解析需要注意的一个关键点。
一定要注意服务解析范围，不要在 Singleton 中解析 Transient 或 Scoped 服务，这可能导致服务状态错误（如导致服务实例生命周期提升为单例，因为单例生命周期的服务对象只会在应用停止的时候释放，而单例对象都没释放，它的依赖项肯定不会释放）。允许的方式有：

• 在 Scoped 或 Transient 服务中解析 Singleton 服务
  
• 在 Scoped 或 Transient 服务中解析 Scoped 服务（不能和前面的Scoped服务相同）
  

如果要在单例生命周期示例中临时解析作用域、瞬时生命周期的服务，可以通过创建一个子作用域的方式。对子作用域 IServiceScope 的工作方式感兴趣的，可阅读一下这篇文章：细聊.Net Core中IServiceScope的工作方式 。


参考文章：
ASP.NET Core 依赖注入 | Microsoft Learn
理解ASP.NET Core - 依赖注入(Dependency Injection)


ASP.NET Core 系列：
目录：ASP.NET Core 系列总结
上一篇：ASP.NET Core - 依赖注入(二)

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！