独立开发者@董川民

Just So So ...

ASP.NET CORE 内置的IOC解读及使用

在我接触IOC和DI 概念的时候是在2016年有幸倒腾Java的时候第一次接触，当时对这两个概念很是模糊；后来由于各种原因又回到.net 大本营，又再次接触了IOC和DI，也算终于搞清楚了IOC和DI 这两个概念关系。使用过ASP.NET Core的人对这两个概念一定不陌生，想必很多人还是很难去理解这两个东西，所以，趁着今天有空，就去把两个概念捋清楚，并将学习过程的知识点记录下来。.

一、概念

1.1 什么是IOC？

Ioc—Inversion of Control，即 控制反转，其是一种 设计思想，而不是一种技术。在没有使用IOC之前，我们一般是通过new来实例化，从而创建一个对象。但是我们使用IOC之后，创建这个对象的控制权将由内部转换到外部，那么这个过程便可以理解为控制反转。也即 把对象转换成抽象对象的依赖.。

同时控制反转也是一个目标，控制反转的优点有如下两点：

  • 可以很好的做到 解耦

  • 屏蔽对象的实现细节，只关心动作不关心动作中的细节。

1.2 什么是DI(依赖注入）？

全称为 DependencyInjection，意思自身对象中的内置对象是通过注入的方式进行创建。形象的说，即由容器动态的将某个依赖关系注入到组件之中。

1.3 IOC和DI的联系？

IOC是一种设计思想，而DI是这种设计思想的一个实现。理解IOC和DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”。●谁依赖于谁：当然是应用程序依赖于IoC容器；●为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；●谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；●注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）

1.4 常见的IOC框架。

微软.net core 内置的DI、Autofac、Unity

以上已经把IOC和DI 这两个联系简要捋清楚了，下面我们一起学习.net core 内置的DI使用。

二、内置IOC

2.1 内置的IOC 有三种生命周期

  • Transient：瞬时生命周期, Transient服务在每次被请求时都会被创建一个新的对象。这种生命周期比较适用于轻量级的无状态服务。

  • Scoped：Scoped生命周期的服务是每次web请求被创建,局部单例对象, 在某个局部内是同一个对象(作用域单例,本质是容器单例);一次请求内是一个单例对象，多次请求则多个不同的单例对象.

  • Singleton：Singleton生命能够周期服务在第一被请求时创建，在后续的每个请求都会使用同一个实例。如果你的应用需要单例服务，推荐的做法是交给服务容器来负责单例的创建和生命周期管理，而不是自己来走这些事情。

我们先来看一张图： ASP.NET CORE 内置的IOC解读及使用

ASP.NET Core本身已经集成了一个轻量级的 IOC容器，开发者只需要定义好接口后（抽象），并且对抽象的接口进行实现，再Startup.cs的ConfigureServices方法里使用对应生命周期的注入，再调用的地方进行使用，比如构造函数注入等等。

在start.up类中ConfigureServices方法对实例进行注册如下代码：


 

  1. // This method gets called by the runtime. Use this method to add services to the container.

  2. public void ConfigureServices(IServiceCollection services)

  3. {

  4. Console.WriteLine("ConfigureServices");

  5. services.AddControllersWithViews();

  8. //注入生命周期为单例的服务

  9. services.AddSingleton<ISingletonService, SingletonService>();

  10. //注入生命周期为Scoped 的服务

  11. services.AddScoped<IScopedService, ScopedService>();

  12. //注入生命周期为瞬时的服务

  13. services.AddTransient<ITransientService, TransientService>();

  14. }

上面代码我分别注册了单例、瞬时、作用域的生命周期的服务。

下面简单写了一个例子让大家看看这三个生命周期的实例的代码

三个生命周期的抽象服务实现代码如下：


 

  1. public class ScopedService : IScopedService

  2. {

  3. public string GetInfo()

  4. {

  5. return $"this is scoped service ";

  6. }

  7. }

  10. public class SingletonService : ISingletonService

  11. {

  12. public string GetInfo()

  13. {

  14. return $"this is singleton service";

  15. }

  16. }

  19. public class TransientService : ITransientService

  20. {

  21. public string GetInfo()

  22. {

  23. return $"this is transient service";

  24. }

  25. }

控制器代码如下：

index.cshtml 视图代码如下：


 

  1. @{

  2. ViewData["Title"] = "Home Page";

  3. }

  6. <b>Transient生命周期</b>

  7. <div>

  8. @Html.Raw(ViewBag.Transient)

  9. </div>

  12. <b>Scoped生命周期</b>

  13. <div>

  14. @Html.Raw(ViewBag.Scope)

  15. </div>

  18. <b>Singletion生命周期</b>

  19. <div>

  20. @Html.Raw(ViewBag.Singletion)

  21. </div>

分别运行两次的结果如下图：

ASP.NET CORE 内置的IOC解读及使用 从上图的运行的每个对象的hashCode 的结果看出 Transient生命周期是每次获得对象都是一次新的对象； Scoped生命周期是在作用域是同一个对象，非作用域内则是新的对象； Singletion生命周期是最好理解的，是这个服务启动后都是一个对象，也即是 全局单例对象。

2.2 注入的几种方式

直接注入IServiceProvider的方式

services.AddSingleton();

然后在构造函数中通过如下方式获取具体实现


 

  1. public HomeController(IServiceProvider serviceProvider)

  2. {

  3. var singletonService = serviceProvider.GetService<SingletonService>();

  4. }

通过GetServices方式

services.AddSingleton();

然后在构造函数中通过如下方式获取具体实现


 

  1. public HomeController(IServiceProvider serviceProvider)

  2. {

  3. var singletonService = serviceProvider.GetService<ISingletonService>();

  4. }

构造函数直接注入方式（推荐）


 

  1. public HomeController(ISingletonService singletonService)

  2. {

  3. var _singletonService =singletonService;

  4. }

集合方式注入

这种方式其实就是省去了注入 IServiceProvider的过程，直接将 GetServices获取的结果进行注入。首先注入 interface及具体实现


 

  1. services.AddSingleton<ISingletonService, SingletonService1>();

  2. services.AddSingleton<ISingletonService, SingletonService2>();

获取的方式如下


 

  1. public HomeController(IEnumerable<ISingletonService> services)

  2. {

  3. var singletoService1 = services.First();

  4. var singletoService2 = services.Skip(1).First();

  5. }

工厂方式注入

然后我们继续注入Func这个工厂，这里我们按 int来返回不同的实现，当然你也可以采用其他方式比如 string


 

  1. services.AddSingleton(provider =>

  2. {

  3. Func<int, ISingletonService> func = n =>

  4. {

  5. switch (n)

  6. {

  7. case 1:

  8. return provider.GetService<SingletonService1>();

  9. case 2:

  10. return provider.GetService<SingletonService2>();

  11. default:

  12. throw new NotSupportedException();

  13. }

  14. };

  15. return func;

  16. });

然后在构造函数中通过如下方式获取具体实现


 

  1. public HomeController(Func<int, ISingletonService> funcFactory)

  2. {

  3. var singletonService1 = funcFactory(1);

  4. var singletonService2 = funcFactory(2);

  5. }

除了以上的几个注入方式外，还可以通过反射的方式批量注入程序集的方式，这里就不一一写出具体的例子，自己去尝试。

三、IOC怎么解耦？

学习到这里，大家对IOC和DI 的使用已经有了一定的掌握，上面我提到过 IOC的目标是 解耦、 屏蔽对象的实现细节这两大优点；再来回顾上面的代码实现 可以发现，推荐的注入方式是通过 抽象接口的方式进行注入而不是直接注入对象方式。

现在我列举一个企业发展过程中很常见的一个例子，比如：我在一家企业担任开发工作，开发了一个电商平台系统，系统中需要用到日志系统，由于当时的各种外在环境，我们使用的日志是 nlog这个日志组件；但是经过平台的不断发展后，nlog 日志组件已经不能满足我们平台的需求，需要寻求更智能的日志系统，比如 Exceptionless，这时候我们就不得不权衡下现有代码的可维护性。刚好这个电商平台系统代码使用了IOC 使得代码可维护性比较强，日志系统耦合性比较低，只需要简单的几行代码即可实现日志系统的大换血。现在来看下电商系统目前使用的日志系统相关的代码。

日志组件服务注册如下代码：


 

  1. services.AddSingleton<ILogService, nLogService>();

各业务中使用nlog代码大概如下：


 

  1. public HomeController(ILogService LogService)

  2. {

  3. _logService =LogService;

  4. _logService.Info("=========开始访问========");

  5. }

从上面的代码中使用日志的相关业务代码都是通过IOC来进行控制反转调用日志服务，隐藏了日志服务业务的实现细节；使用业务方无需关注日志的实现细节，从而达到 了高度解耦的效果- 屏蔽对象实现细节。

现在我们进行日志系统大换血代码只需要实现一个新的日志服务，我这里创建 ExceptionlessLogService类继承 ILogService即可，同时安排对应的人去实现 ExceptionlessLogService这个类就可以达到日志系统升级的效果。

更换后的代码如下：


 

  1. services.AddSingleton<ILogService, NLogService>();

  2. 改成

  3. services.AddSingleton<ILogService, ExceptionlessLogService>();

这样就达到了一行代码升级了整个系统的日志系统，业务调用方无需任何的改动。

本文作者：Jlion信息来源：公众号 dotNET博士所属分类：.NET

董川民

Life is like a box of chocolates,you never know what you're going to get.
ChongQing Movie Motorcycle Website