ASP.NET Core中的依赖注入【上】

此为系列文章，对MSDN ASP.NET Core 的官方文档进行系统学习与翻译。其中或许会添加本人对 ASP.NET Core 的浅显理解

ASP.NET Core支持DI软件设计模式，其是一种为了在类及其依赖对象之间实现控制反转（IoC）的一项技术。获取更多特定于MVC控制器的依赖注入的信息，可以参考Dependency injection into controllers in ASP.NET Core。

依赖注入概述

        任何其他对象需要的一个对象都可以称之为依赖。检查如下具有一个WriteMessage方法的MyDependency类，app中的其他类会依赖它：

     

public class MyDependency
{
    public MyDependency()
    {
    }

    public Task WriteMessage(string message)
    {
        Console.WriteLine(
            $"MyDependency.WriteMessage called. Message: {message}");

        return Task.FromResult(0);
    }
}

         我们可以创建一个MyDependency类的实例来使得WriteMessage方法对于一个类是可用的。如下所示，MyDependency类便是IndexModel类的一个依赖：

   

public class IndexModel : PageModel
{
    MyDependency _dependency = new MyDependency();

    public async Task OnGetAsync()
    {
        await _dependency.WriteMessage(
            "IndexModel.OnGetAsync created this message.");
    }
}

        这个类创建并直接依赖于MyDependency类的实例。代码依赖（正如上述代码）是有问题的，基于如下理由，我们应该避免它：

•                 如果要用一个不同的实现来替换MyDependency，使用了MyDependency的所有类必须要进行改动。
•                 如果MyDependency类也具有依赖，那么MyDependency类的使用类必须对它们进行配置，会使得配置代码散布在整个app中。
•                 这种实现难以进行单元测试，app应该使用一个模拟的或者微小的MyDependency类来进行单元测试，但在这种模式下这是不可能的。

       依赖注入通过以下方式解决这些问题：

•               使用了接口或基类来对依赖的实现进行抽象。
•               在一个服务容器中对依赖进行注册。ASP.NET Core提供了一个内置的服务容器，IServiceProvider。服务在Startup.ConfigureServices方法中进行注册。
•               将服务注入到使用它们的类的构造函数中。框架负责创建一个依赖的实例，并在不再需要它的时候将其销毁。

       在示例代码中，IMyDependency接口定义了服务提供给app的方法：

      

public interface IMyDependency
{
    Task WriteMessage(string message);
}

        一个具体类型MyDependency实现了这个接口：

 

public class MyDependency : IMyDependency
{
    private readonly ILogger<MyDependency> _logger;

    public MyDependency(ILogger<MyDependency> logger)
    {
        _logger = logger;
    }

    public Task WriteMessage(string message)
    {
        _logger.LogInformation(
            "MyDependency.WriteMessage called. Message: {MESSAGE}", 
            message);

        return Task.FromResult(0);
    }
}

         MyDependency在其构造函数中 请求了一个ILogger<TCategoryName>。以链接的方式来使用依赖注入并不少见。每一个被请求的依赖都会依次请求它们自己的依赖。容器会对图形化的依赖进行解析并最终返回一个完整的解析后的服务。这一系列需要解析的服务被称为依赖树，或者依赖图，对象图。

        IMyDependency以及ILogger<TCategoryName>必须在服务容器中进行注册。IMyDependency在Startup.ConfigureServices中进行注册；而日志抽象架构负责ILogger<TCategoryName>的注册。所以它是一个框架提供的服务，其被框架默认注册。

        容器通过使用(generic) open types来对ILogger<TCategoryName>进行解析，而不需要对每一个泛型构造类型进行注册：

services.AddSingleton(typeof(ILogger<>), typeof(Logger<>));

       在示例代码中，使用具体类型MyDependency来对IMyDependency服务进行注册。这个注册将服务的生命周期限定为一个请求的生命周期，服务的生命周期会在后续进行讨论：

  

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages();

    services.AddScoped<IMyDependency, MyDependency>();
    services.AddTransient<IOperationTransient, Operation>();
    services.AddScoped<IOperationScoped, Operation>();
    services.AddSingleton<IOperationSingleton, Operation>();
    services.AddSingleton<IOperationSingletonInstance>(new Operation(Guid.Empty));

    // OperationService depends on each of the other Operation types.
    services.AddTransient<OperationService, OperationService>();
}

注意，每一个services.Add{SERVICE_NAME}扩展方法都会添加（并潜在配置）了服务。比如services.AddMvc()添加了Razor视图和MVC支持。我们建议app遵从此约定，将扩展方法放置在此命名空间Microsoft.Extensions.DependencyInjection以对服务注册的分组进行封装。

        如果服务的构造函数需要一个内置类型，比如String，那么可以使用配置或者选项模式进行注入：

  

public class MyDependency : IMyDependency
{
    public MyDependency(IConfiguration config)
    {
        var myStringValue = config["MyStringKey"];

        // Use myStringValue
    }

    ...
}

          服务实例被使用它的类的构造函数所请求并被分配给一个私有字段。在整个类中，便可以使用这个字段来访问服务。

          在示例代码中，IMyDependency的实例会被请求并用来调用服务的WriteMessage方法。

public class IndexModel : PageModel
{
    private readonly IMyDependency _myDependency;

    public IndexModel(
        IMyDependency myDependency, 
        OperationService operationService,
        IOperationTransient transientOperation,
        IOperationScoped scopedOperation,
        IOperationSingleton singletonOperation,
        IOperationSingletonInstance singletonInstanceOperation)
    {
        _myDependency = myDependency;
        OperationService = operationService;
        TransientOperation = transientOperation;
        ScopedOperation = scopedOperation;
        SingletonOperation = singletonOperation;
        SingletonInstanceOperation = singletonInstanceOperation;
    }

    public OperationService OperationService { get; }
    public IOperationTransient TransientOperation { get; }
    public IOperationScoped ScopedOperation { get; }
    public IOperationSingleton SingletonOperation { get; }
    public IOperationSingletonInstance SingletonInstanceOperation { get; }

    public async Task OnGetAsync()
    {
        await _myDependency.WriteMessage(
            "IndexModel.OnGetAsync created this message.");
    }
}

 注入到Startup中的服务

         当使用泛型宿主（IHostBuilder）时，只有如下的服务类型可以被注入到Startup的构造函数中：          

• IWebHostEnvironment
• IHostEnvironment
• IConfiguration

       服务可以被注入到Startup.Configure方法：

 

public void Configure(IApplicationBuilder app, IOptions<MyOptions> options)
{
    ...
}

        更多信息，请参考App startup in ASP.NET Core。

框架提供的服务

       Startup.ConfigureServices方法负责定义app使用的服务，包括一些平台级特性，比如Entity Framework Core和ASP.NET Core MVC。根据how the host was configured，提供给ConfigureServices的初始IServiceCollection具有一些由框架定义的服务。对于一个基于ASP.NET Core模板的app来说，具有几百个框架定义的服务并不少见。下面的表格列出了一小部分框架定义的服务：

       

服务类型	生命周期
Microsoft.AspNetCore.Hosting.Builder.IApplicationBuilderFactory	Transient
IHostApplicationLifetime	Singleton
IWebHostEnvironment	Singleton
Microsoft.AspNetCore.Hosting.IStartup	Singleton
Microsoft.AspNetCore.Hosting.IStartupFilter	Transient
Microsoft.AspNetCore.Hosting.Server.IServer	Singleton
Microsoft.AspNetCore.Http.IHttpContextFactory	Transient
Microsoft.Extensions.Logging.ILogger<TCategoryName>	Singleton
Microsoft.Extensions.Logging.ILoggerFactory	Singleton
Microsoft.Extensions.ObjectPool.ObjectPoolProvider	Singleton
Microsoft.Extensions.Options.IConfigureOptions<TOptions>	Transient
Microsoft.Extensions.Options.IOptions<TOptions>	Singleton
System.Diagnostics.DiagnosticSource	Singleton
System.Diagnostics.DiagnosticListener	Singleton

使用扩展方法注册额外的服务

       当一个服务集合扩展方法可用来注册一个服务（以及它所依赖的服务）时，按照惯例是使用一个单独的Add{SERVICE_NAME}扩展方法来注册这个服务所需要的所有服务。下面的代码演示了如何使用扩展方法AddDbContext<TContext> 和AddIdentityCore:来给容器添加额外的服务：

public void ConfigureServices(IServiceCollection services)
{
    ...

    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddIdentity<ApplicationUser, IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddDefaultTokenProviders();

    ...
}

         更多信息，请参考API文档中的ServiceCollection类。

服务生命周期

        为每一个注册的服务选择一个合适的生命周期。ASP.NET Core服务可被配置为如下的生命周期：

        Transient

                 每一次服务被从服务容器中请求都会创建一个Transient生命周期服务（AddTransient）。这种生命周期对于轻量级，无状态的服务来说，工作得最好。

        Scoped

                每一次的客户端请求都会创建一个Scoped生命周期服务。

                注意，当在中间件中使用一个scoped服务时，将服务注入到Invoke或者InvokeAsync方法。不要通过构造函数注入的方式进行注入，因为其迫使服务表现的像一个singleton，更多信息，请参考Write custom ASP.NET Core middleware。

       Singleton

               当Singleton生命周期服务第一次被请求时（当Startup.ConfigureServices开始运行，并且服务的一个实例被服务容器所指定），它们便会被创建。每一个后续的请求都会使用同一个实例。如果app需要单例行为，我们推荐使用服务容器来管理服务生命周期。不用实现单例模式并提供用户代码在类中管理服务对象的生命周期。

      警告：从一个单例中解析scoped服务是很危险的。它会导致服务在处理后续的请求时具有不正确的状态。