七叶笔记 » golang编程 » .Net Core 依赖注入（IOC） 一些简单的使用技巧

.Net Core 依赖注入（IOC） 一些简单的使用技巧

分类: golang编程 | 浏览: 233

　. Net Core 在使用IOC后，我们不必再浪费精力在管理实例的生命周期上，交给IOC代替我们管理，减少我们成吨的代码，面向接口编程更是灵活到了极致，而IOC的三种生命周期应该怎么去使用呢，Transient（瞬态）、Scoped（作用域）、Singleton（单例）。

Transient（瞬态）

　　这个没什么好说的，就是每次注入的时候，容器自动 new 一个实例，用完就丢；

Scoped（作用域）

　　以Web来说， 作用域 的生命周期就是当次请求，请求开始后的第一次注入，就是它生命的开始，直到请求结束；

　　我个人常用来减少数据获取，提升请求响应，举一个例子：A服务是获取全国地级市信息的，以作用域的方式注册到IOC容器中，B、C、D 都注入了A服务并使用了它；一个业务接口，刚好涉及到了B、C、D，当接口被调用，代码执行到了B，第一次调用了 A 服务请求数据库获取了全国地级市数据；然后执行到了C，又一次使用了A服务获取了数据，最后D；一个请求下来，A被使用了3次，获取了3个同样的数据结果，这完全是在浪费资源； 

  1 public class AService
 2 {
 3     public async CityData GetCityDataAsync()
 4     {
 5         return await GetDatasFromApi();
 6     }
 7 }
 8 
 9 public class BService
10 {
11      private  readonly AService _aService;
12 
13     public BService(AService aService)
14     {
15         _aService = aService;
16     }
17     
18     public async Task Execute()
19     {
20         await _aService.GetCityDataAsync();
21     }
22 }
23 
24 public class CService
25 {
26     private readonly AService _aService;
27 
28     public CService(AService aService)
29     {
30         _aService = aService;
31     }
32 
33     public async Task Execute()
34     {
35         await _aService.GetCityDataAsync();
36     }
37 }
38 
39 public class DService
40 {
41     private readonly AService _aService;
42 
43     public DService(AService aService)
44     {
45         _aService = aService;
46     }
47 
48     public async Task Execute()
49     {
50         await _aService.GetCityDataAsync();
51     }
52 }

　　那我们应该怎么做呢，首先我们回顾一下 Scoped 的生命周期，可以说是一个实例，贯穿了整一个请求，那我们是不是可以定义一个变量，请求数据前先判断这个变量有没有值，没有就去获取数据，给它赋值，下次再调用的时候，直接返回这个变量的数据，这样不管这个服务被调用多少次，它也只是调用了一次数据库，大大节省了资源。 

  1 public class AService
 2 {
 3     private List<CityData> cityDatas;
 4         
 5     public async List<CityData> GetCityDataAsync()
 6     {
 7         if(cityDatas == null|| !cityDatas.Any())
 8         {
 9             cityDatas = await GetDatasFromApi();
10         }
11         
12         return cityDatas;
13     }
14 }

　　有人可能说会说了，不就是多调用几次数据库，现在服务器的性能这么好，不在乎这一点的资源；确实，如果只是多调用几次数据库，对于一些小系统来说，跟挠痒痒一样，那这里的调用数据库换成调用 WebApi 呢？如果还是调用第三方的 API 呢？一次Http请求，不往大的说，从请求到获取到数据，花个100ms很正常吧（网络非常好的情况当我没说），那这个接口不需要多，调用10次就1s了，还没算上其它业务逻辑的耗时呢，如果还需要调用其它的api，那响应时间就更长咯，难道你让用户打开一个页面，或者点击一个按钮，需要等上两三秒才有响应吗，这样的用户体验就非常糟糕了。

Singleton（单例）

　　来自依赖关系注入容器的服务实现的每一个后续请求都使用同一个实例。 如果应用需要单一实例行为，则允许服务容器管理服务的生存期。必须是 线程 安全的，并且通常在无状态服务中使用。

　　在单例中，不要直接注入作用域的服务， 这会引起很多莫名其妙的错误(经过评论区大佬的指正，修正这个不恰当的用词，这里引用大佬的一段话) 单例中引用Scoped，Scoped就会提升为单例，这就很容易发生错误 ，一定要使用的话，就自己创建，自己管理它的生命周期： 

 public class Scope
{
    private readonly IServiceScopeFactory _serviceScopeFactory;

    public Scope(IServiceScopeFactory serviceScopeFactory)
    {
        _serviceScopeFactory = serviceScopeFactory;
    }

    public async Task CreateScope()
    {
        using var scope = _serviceScopeFactory.CreateScope();

        var service = scope.ServiceProvider.GetRequiredService<IService>();
    }
}

ActivatorUtilities

　　有些情况下，例如当你不想把使用次数极低的类注册到容器中，或者这个类的 构造函数 需要传入一些参数，但是又需要用到容器中的服务的时候，你可以使用 ActivatorUtilities 中的 CreateInstance 去创建它，它会自动给构造函数注入所需的服务，并且还可以给构造函数传参，满足上面所说情况的需求。 

  1 public class TestTask : ITask
 2 {
 3     private readonly IServiceScopeFactory _serviceScopeFactory;
 4 
 5     private readonly I RabbitMQ Service _rabbitMQService;
 6 
 7     private readonly string _name;
 8 
 9     public TestTask(IServiceScopeFactory serviceScopeFactory, I rabbitMQ Service rabbitMQService, string name)
10     {
11         _serviceScopeFactory = serviceScopeFactory;
12         _rabbitMQService = rabbitMQService;
13         _name = name;
14     }
15 
16     /// <summary>
17     /// 
18     /// </summary>
19     /// <param name="cancellationToken"></param>
20     /// <returns></returns>
21     /// < exception  cref="NotImplementedException"></exception>
22     public async Task Execute(CancellationToken cancellationToken)
23     {
24         try
25         {
26             using var scope = _serviceScopeFactory.CreateScope();
27 
28             var executionService = scope.ServiceProvider.GetService<ITaskExecutionService>();
29 
30             if (executionService != null)
31             {
32                 await _rabbitMQService.RabbitMQReceiveService.SingleAsync(executionService.ExecuteAsync);
33             }
34         }
35         catch (Exception err)
36         {
37 
38             Console.WriteLine(err.Message);
39         }
40     }
41 }

　　使用 ActivatorUtilities 创建： 

 1 var testTask = ActivatorUtilities.CreateInstance<TestTask>(serviceProvider, "test");
2 
3 await testTask.Execute(new CancellationToken());

原文链接：

相关文章