ASP.NET Core 依赖注入基本用法

ASP.NET Core 依赖注入

ASP.NET Core从框架层对依赖注入提供支持。也就是说，若是你不了解依赖注入，将很难适应 ASP.NET Core的开发模式。本文将介绍依赖注入的基本概念，并结合代码演示如何在 ASP.NET Core中使用依赖注入。

什么是依赖注入？

百度百科对于依赖注入的介绍：

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，能够用来减低计算机代码之间的耦合度。其中最多见的方式叫作依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。经过控制反转，对象在被建立的时候，由一个调控系统内全部对象的外界实体将其所依赖的对象的引用传递给它。也能够说，依赖被注入到对象中。

从百科的介绍中能够看出，依赖注入和控制反转是一回事，依赖注入是一种新的设计模式，经过正确使用依赖注入的相关技术，能够下降系统耦合度，增长系统的可扩展性。

咱们来看一个例子：

public interface IInterfaceA
{ }

public interface IInterfaceB
{ }

public class ClassA : IInterfaceA
{
    private IInterfaceB B { get; set; }

    public ClassA(IInterfaceB b)
    {
        this.B = b;
    }
}

public class ClassB : IInterfaceB
{ }

这个时候，若是咱们想要获取IInterfaceA的实例，若是不采用依赖注入，咱们的作法一般是这样的：

IInterfaceB b = new ClassB();
IInterfaceA a = new ClassA(b);

这个时候IInterfaceA的控制权，在实例化的时候就已经被限定死了，没有任何想象空间，就是ClassA的实例，而且咱们还要手工的初始化IInterfaceB，一样B的控制权也被限定死了。这样的代码毫无设计、也极不利于扩展。

若是采用依赖注入，咱们看一下代码：

var a = container.GetService<IInterfaceA>();

这个时候接口A和B的控制权是由容器来控制的，咱们能够经过向容器中注入不一样的接口实现来扩展系统的灵活性，因为将控制权交给了IoC容器，咱们还能够经过配置的方式灵活的控制对象的生命周期，这一点也是手工建立对象没法实现的。

控制反转的关系图以下（图片来源于官网）：

ASP.NET Core中的依赖注入

上面介绍了依赖注入的基本概念，那么在 ASP.NET Core中，咱们该如何使用依赖注入呢？在 ASP.NET Core中已经内置了一套依赖注入的容器，咱们能够直接使用。

在Startup.ConfigureServices中添加咱们要注册的服务和实现，添加的时候能够对服务的生命周期进行相应的配置，而后就能够在PageModel、Controller、Views等须要的地方使用了。

下面的示例将演示如何注册服务，代码来源于官网。首先要定义一个服务接口，并实现这个接口：

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

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);
    }
}

而后咱们进行服务注册：

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IMyDependency, MyDependency>();
    services.AddMvc();
}

这里咱们添加了IMyDependency的注册，同时也添加了使用Mvc所须要的服务的注册。这里有两个问题须要说明：

• AddScoped是添加一个服务注册，Scoped是该服务的生命周期，表示按照做用于建立该服务，若是做用域中屡次使用到该服务，则只建立一个对象。好比每个HTTP请求都是一个做用域，那么在这个请求处理过程当中，容器只会建立一个对象。与Scoped对应的还有其它的生命周期，咱们将服务的生命周期列举以下：

  • Transient：瞬时服务，表示每次使用都会建立新的对象
  • Scoped：做用域服务，表示每次请求只建立一个对象。这里须要特殊说明一下，若是你的服务是一个中间件，不受此约束，由于中间件都是强制单例的。若是要在中间件中使用Scoped服务，则须要将服务注入到Invoke或InvokeAsync方法的参数中，此处能够参考 ASP.NET Core 中间件基本用法
  • Singleton：单例服务，表示每一个应用程序域只会建立一个实力。

• 基于约定，ASP.NET Core推荐咱们采用相似于Add{SERVICE_NAME}的方式添加服务的注册，好比services.AddMvc()，这种方式能够经过扩展方法来实现，代码以下：

namespace Microsoft.Extensions.DependencyInjection
{
    public static partial class MyDependencyExtensions
    {
        public static IServiceCollection AddMyDependency(this IServiceCollection services)
        {
            return services.AddScoped<IMyDependency, MyDependency>();
        }
    }
}

使用依赖注入

在了解了依赖注入的基本用法以后，咱们如今来了解一下如何将服务注入到Controller、Views中。

在控制器中注入服务

最常规的用法是采用构造函数注入的方式，将一个服务注入到控制器中，代码以下：

public class DefaultController : Controller
{
    private readonly ILogger<DefaultController> logger;

    public DefaultController(ILogger<DefaultController> logger)
    {
        this.logger = logger;
    }
}

构造函数注入是最经常使用的注入方式，这种方式要求依赖者提供公有的构造函数，并将依赖项经过构造函数的方式传入依赖者，完成对依赖项的赋值。

除此以外，还能够经过参数注入的方式，将依赖项注入到Action中，这里使用到FromServices特性：

public IActionResult Index([FromServices]ILogger<DefaultController> logger)
{
    throw new NotImplementedException();
}

ASP.NET Core 提供了这种支持，可是做者并不推荐这种操做

在视图中注入服务

ASP.NET Core 支持将依赖关系注入到视图，代码以下：

@using Microsoft.Extensions.Configuration
@inject IConfiguration Configuration
@{
   string myValue = Configuration["root:parent:child"];
   ...
}

上面的代码演示了将IConfiguration服务注入到视图中，从而实如今视图中读取配置的功能。

有时候将服务注入到视图中会颇有用（例如本地化），可是做者也并非很推荐这种作法，由于这样作容易形成视图和控制器的边界不清晰。

在PageModel中注入服务

在PageModel中注入服务的方式，与在Controller中注入服务的方式类似：

public class IndexModel : PageModel
{
    private readonly IMyDependency _myDependency;

    public IndexModel(IMyDependency myDependency)
    {
        _myDependency = myDependency;
    }
}

在main方法中获取服务

public static void Main(string[] args)
{
    var host = CreateWebHostBuilder(args).Build();

    using (var serviceScope = host.Services.CreateScope())
    {
        var services = serviceScope.ServiceProvider;

        try
        {
            var serviceContext = services.GetRequiredService<MyScopedService>();
            // Use the context here
        }
        catch (Exception ex)
        {
            var logger = services.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred.");
        }
    }

    host.Run();
}

在HttpContext.RequestServices中获取服务

这种方式不利于测试，不推荐此种用法。

虽然优先推荐经过构造函数的方式注入来获取服务，可是很难避免有些时候须要手工获取服务，在使用手工获取服务的时候，咱们应当从HttpContext.RequestServices中获取。

使用第三方依赖注入框架

ASP.NET Core内置的依赖注入框架功能有限，当咱们想使用第三方框架的特性时，咱们能够替换默认依赖注入框架。

ASP.NET Core内置的依赖注入框架未包含的特性：

• 属性注入
• 基于名称的注入
• 子容器
• 自定义生命周期管理
• 对lazy对象初始化的Func 支持

若是要是用这些功能，咱们可使用第三方框架。本文采用官方文档中的Autofac框架。

• 首先添加 Autofac、Autofac.Extensions.DependencyInjection 的引用
• 在Startup.ConfigureServices中配置容器，并返回IServiceProvider。在使用第三方容器时，必须返回IServiceProvider。

public IServiceProvider ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
    // Add other framework services

    // Add Autofac
    var containerBuilder = new ContainerBuilder();
    containerBuilder.RegisterModule<DefaultModule>();
    containerBuilder.Populate(services);
    var container = containerBuilder.Build();
    return new AutofacServiceProvider(container);
}

• 配置Autofac的Module，用来注册服务等

public class DefaultModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<CharacterRepository>().As<ICharacterRepository>();
    }
}

参考资料

• https://baike.baidu.com/item/控制反转/1158025
• https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/dependency-injection
• https://docs.microsoft.com/zh-cn/dotnet/standard/modern-web-apps-azure-architecture/architectural-principles