ASP.NET Core 2 学习笔记（四）依赖注入

时间  2019-11-29
标签 asp.net asp core 学习 笔记 依赖 注入 栏目 ASP 繁體版
原文   原文链接

ASP.NET Core使用了大量的依赖注入(Dependency Injection, DI)，把控制反转(Inversion Of Control, IoC)运用的至关巧妙。DI可算是ASP.NET Core最精华的一部分，有用过Autofac或相似的DI Framework对此应该不陌生。
本篇将介绍ASP.NET Core的依赖注入(Dependency Injection)。html

DI 容器介绍

在没有使用DI Framework 的状况下，假设在UserController 要调用UserLogic，会直接在UserController 实例化UserLogic，以下：git

public class UserLogic {
    public void Create(User user) {
        // ...
    }
}

public class UserController : Controller {
    public void Register(User user){
        var logic = new UserLogic();
        logic.Create(user);
        // ...
    }
}

以上程序基本没什么问题，可是依赖关系差了点。UserController 必需要依赖UserLogic才能够运行，拆出接口改为：github

public interface IUserLogic {
    void Create(User user);
}

public class UserLogic : IUserLogic {
    public void Create(User user) {
        // ...
    }
}

public class UserController : Controller {
    private readonly IUserLogic _userLogic;

    public UserController() {
        _userLogic = new UserLogic();
    }

    public void Register(User user){
        _userLogic.Create(user);
        // ...
    }
}

UserController 与UserLogic 的依赖关系只是从Action 移到构造方法中，依然仍是很强的依赖关系。bash

ASP.NET Core透过DI容器，切断这些依赖关系，实例的产生不在使用方(指上例UserController构造方法中的new)，而是在DI容器。
DI容器的注册方式也很简单，在Startup.ConfigureServices注册。以下：spa

Startup.cs.net

// ...
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc();
    }
}

services就是一个DI容器。
此例把MVC的服务注册到DI容器，等到须要用到MVC服务时，才从DI容器取得对象实例。　3d

基本上要注入到Service的类没什么限制，除了静态类。
如下示例就只是通常的Class继承Interface：code

public interface ISample
{
    int Id { get; }
}

public class Sample : ISample
{
    private static int _counter;
    private int _id;

    public Sample()
    {
        _id = ++_counter;
    }

    public int Id => _id;
}

要注入的Service须要在Startup.ConfigureServices中注册实例类型。以下：htm

Startup.cs对象

// ...
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // ...
        services.AddScoped<ISample, Sample>();
    }
}
  • 第一个泛型为注入的类型
    建议用Interface来包装，这样在才能把依赖关系拆除。
  • 第二个泛型为实例的类型

DI 运行方式

ASP.NET Core的DI是采用Constructor Injection，也就是说会把实例化的物件从建构子传入。
若是要取用DI容器内的物件，只要在建构子加入相对的Interface便可。例如：

Controllers\HomeController.cs

using Microsoft.AspNetCore.Mvc;
using MyWebsite.Models;

namespace MyWebsite.Controllers
{
    public class HomeController : Controller
    {
        private readonly ISample _sample;

        public HomeController(ISample sample)
        {
            _sample = sample;
        }

        public string Index()
        {
            return $"[ISample]\r\n"
                 + $"Id: {_sample.Id}\r\n"
                 + $"HashCode: {_sample.GetHashCode()}\r\n"
                 + $"Tpye: {_sample.GetType()}";
        }
    }
}

输出内容以下：

[ISample]
Id: 1
HashCode: 52582687
Tpye: MyWebsite.Models.Sample

ASP.NET Core 实例化Controller 时，发现构造方法中有ISample 这个类型的参数，就把Sample 的实例注入给该Controller。

每一个Request 都会把Controller 实例化，因此DI 容器会从构造方法注入ISample 的实例，把sample 存到变量_sample 中，就能确保Action 可以使用到被注入进来的ISample 实例。

注入实例过程，情境以下：

Service 生命周期

注册在DI 容器的Service 分三种生命周期：

  • Transient
    每次注入时，都从新new一个新的实例。
  • Scoped
    每一个Request都从新new一个新的实例，同一个Request无论通过多少个Pipeline都是用同一个实例。上例所使用的就是Scoped。
  • Singleton
    被实例化后就不会消失，程式运行期间只会有一个实例。

小改一下Sample 类的代码：

namespace MyWebsite.Models
{
    public interface ISample
    {
        int Id { get; }
    }

    public interface ISampleTransient : ISample
    {
    }

    public interface ISampleScoped : ISample
    {
    }

    public interface ISampleSingleton : ISample
    {
    }

    public class Sample : ISampleTransient, ISampleScoped, ISampleSingleton
    {
        private static int _counter;
        private int _id;

        public Sample()
        {
            _id = ++_counter;
        }

        public int Id => _id;
    }
}

在Startup.ConfigureServices中注册三种不一样生命周期的服务。以下：

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddTransient<ISampleTransient, Sample>();
        services.AddScoped<ISampleScoped, Sample>();
        services.AddSingleton<ISampleSingleton, Sample>();
        // Singleton 也能够用如下方法注册
        // services.AddSingleton<ISampleSingleton>(new Sample());
    }
}

Service Injection

只要是透过WebHost产生实例的类型，均可以在构造方法注入。

因此Controller、View、Filter、Middleware或自定义的Service等均可以被注入。
此篇我只用Controller、View、Service作为范例。

Controller

在TestController 中注入上例的三个Services：

Controllers\TestController.cs

using Microsoft.AspNetCore.Mvc;
using MyWebsite.Models;

namespace MyWebsite.Controllers
{
    public class TestController : Controller
    {
        private readonly ISample _transient;
        private readonly ISample _scoped;
        private readonly ISample _singleton;

        public TestController(
            ISampleTransient transient,
            ISampleScoped scoped,
            ISampleSingleton singleton)
        {
            _transient = transient;
            _scoped = scoped;
            _singleton = singleton;
        }

        public IActionResult Index()
        {
            ViewBag.TransientId = _transient.Id;
            ViewBag.TransientHashCode = _transient.GetHashCode();

            ViewBag.ScopedId = _scoped.Id;
            ViewBag.ScopedHashCode = _scoped.GetHashCode();

            ViewBag.SingletonId = _singleton.Id;
            ViewBag.SingletonHashCode = _singleton.GetHashCode();
            return View();
        }
    }
}

Views\Test\Index.cshtml

<table border="1">
    <tr><td colspan="3">Cotroller</td></tr>
    <tr><td>Lifetimes</td><td>Id</td><td>Hash Code</td></tr>
    <tr><td>Transient</td><td>@ViewBag.TransientId</td><td>@ViewBag.TransientHashCode</td></tr>
    <tr><td>Scoped</td><td>@ViewBag.ScopedId</td><td>@ViewBag.ScopedHashCode</td></tr>
    <tr><td>Singleton</td><td>@ViewBag.SingletonId</td><td>@ViewBag.SingletonHashCode</td></tr>
</table>

输出内容以下：

 

从左到又打开页面三次，能够发现Singleton的Id及HashCode都是同样的，如今还看不太能看出来Transient及Scoped的差别。

Service 实例产生方式：

 

图例说明：

  • A为Singleton对象实例
    一但实例化，就会一直存在于DI容器中。
  • B为Scoped对象实例
    每次Request就会产生新的实例在DI容器中，让同Request周期的使用方，拿到同一个实例。
  • C为Transient对象实例
    只要跟DI容器请求这个类型，就会取得新的实例。

View

View注入Service的方式，直接在*.cshtml使用@inject：

Views\Test\Index.cshtml

@using MyWebsite.Models

@inject ISampleTransient transient
@inject ISampleScoped scoped
@inject ISampleSingleton singleton

<table border="1">
    <tr><td colspan="3">Cotroller</td></tr>
    <tr><td>Lifetimes</td><td>Id</td><td>Hash Code</td></tr>
    <tr><td>Transient</td><td>@ViewBag.TransientId</td><td>@ViewBag.TransientHashCode</td></tr>
    <tr><td>Scoped</td><td>@ViewBag.ScopedId</td><td>@ViewBag.ScopedHashCode</td></tr>
    <tr><td>Singleton</td><td>@ViewBag.SingletonId</td><td>@ViewBag.SingletonHashCode</td></tr>
</table>
<hr />
<table border="1">
    <tr><td colspan="3">View</td></tr>
    <tr><td>Lifetimes</td><td>Id</td><td>Hash Code</td></tr>
    <tr><td>Transient</td><td>@transient.Id</td><td>@transient.GetHashCode()</td></tr>
    <tr><td>Scoped</td><td>@scoped.Id</td><td>@scoped.GetHashCode()</td></tr>
    <tr><td>Singleton</td><td>@singleton.Id</td><td>@singleton.GetHashCode()</td></tr>
</table>

输出内容以下：

从左到又打开页面三次，Singleton的Id及HashCode如前例是同样的。
Transient及Scoped的差别在此次就有明显差别，Scoped在同一次Request的Id及HashCode都是同样的，如红紫篮框。

Service

简单创建一个CustomService，注入上例三个Service，代码相似TestController。以下：

Services\CustomService.cs

using MyWebsite.Models;

namespace MyWebsite.Services
{
    public class CustomService
    {
        public ISample Transient { get; private set; }
        public ISample Scoped { get; private set; }
        public ISample Singleton { get; private set; }

        public CustomService(ISampleTransient transient,
            ISampleScoped scoped,
            ISampleSingleton singleton)
        {
            Transient = transient;
            Scoped = scoped;
            Singleton = singleton;
        }
    }
}

注册CustomService

Startup.cs

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // ...
        services.AddScoped<CustomService, CustomService>();
    }
}

第一个泛型也能够是类，不必定要是接口。
缺点是使用方以Class做为依赖关系，变成强关联的依赖。

在View 注入CustomService：

Views\Home\Index.cshtml

@using MyWebsite
@using MyWebsite.Models
@using MyWebsite.Services

@inject ISampleTransient transient
@inject ISampleScoped scoped
@inject ISampleSingleton singleton
@inject CustomService customService

<table border="1">
    <tr><td colspan="3">Cotroller</td></tr>
    <tr><td>Lifetimes</td><td>Id</td><td>Hash Code</td></tr>
    <tr><td>Transient</td><td>@ViewBag.TransientId</td><td>@ViewBag.TransientHashCode</td></tr>
    <tr><td>Scoped</td><td>@ViewBag.ScopedId</td><td>@ViewBag.ScopedHashCode</td></tr>
    <tr><td>Singleton</td><td>@ViewBag.SingletonId</td><td>@ViewBag.SingletonHashCode</td></tr>
</table>
<hr />
<table border="1">
    <tr><td colspan="3">View</td></tr>
    <tr><td>Lifetimes</td><td>Id</td><td>Hash Code</td></tr>
    <tr><td>Transient</td><td>@transient.Id</td><td>@transient.GetHashCode()</td></tr>
    <tr><td>Scoped</td><td>@scoped.Id</td><td>@scoped.GetHashCode()</td></tr>
    <tr><td>Singleton</td><td>@singleton.Id</td><td>@singleton.GetHashCode()</td></tr>
</table>
<hr />
<table border="1">
    <tr><td colspan="3">Custom Service</td></tr>
    <tr><td>Lifetimes</td><td>Id</td><td>Hash Code</td></tr>
    <tr><td>Transient</td><td>@customService.Transient.Id</td><td>@customService.Transient.GetHashCode()</td></tr>
    <tr><td>Scoped</td><td>@customService.Scoped.Id</td><td>@customService.Scoped.GetHashCode()</td></tr>
    <tr><td>Singleton</td><td>@customService.Singleton.Id</td><td>@customService.Singleton.GetHashCode()</td></tr>
</table>

输出内容以下：

 

从左到又打开页面三次：

  • Transient
    如预期，每次注入都是不同的实例。
  • Scoped
    在同一个Requset中，不管是在哪边被注入，都是一样的实例。
  • Singleton
    无论Requset多少次，都会是同一个实例。

参考

Introduction to Dependency Injection in ASP.NET Core 
ASP.NET Core Dependency Injection Deep Dive

 

老司机发车啦：https://github.com/SnailDev/SnailDev.NETCore2Learning

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程