第7课：用Autofac增强容器能力

学习分享 丨作者 / 郑 子 铭 丨公众号 / DotNet NB / CloudNative NB

这一节讲解使用第三方框架来扩展依赖注入容器

什么情况下需要我们引入第三方容器组件？

大部分情况下，默认的容器组件足够使用

当需要一些非常特殊的场景如下：

1、基于名称的注入：需要把一个服务按照名称来区分它的不同实现的时候

2、属性注入：直接把服务注册到某一个类的属性里面去，而不需要定义构造函数，比如之前的 FromService 和 构造函数入参

3、子容器：可以理解为之前讲过的 Scope，但实际上还可以用第三方的框架实现一些特殊的子容器

4、基于动态代理的 AOP：需要在服务中注入额外的行为的时候，可以用动态代理的能力

.NET Core 的依赖注入框架，它的核心扩展点是 IserviceProviderFactory

第三方的依赖注入容器都是用了这个类来作为扩展点，把自己注入到整个框架里来

也就是说在使用这些依赖注入框架的时候，不需要关注说谁家的特性，谁家的接口是什么样子，只需要关注官方核心的定义就可以了，不需要直接依赖这些框架

服务

namespace DependencyInjectionAutofacDemo.Services
{
    public interface IMyService
    {
        void ShowCode();
    }
    public class MyService : IMyService
    {
        public void ShowCode()
        {
            Console.WriteLine($"MyService.ShowCode:{GetHashCode()}");
        }
    }

    public class MyServiceV2 : IMyService
    {
        /// <summary>
        /// 用于演示属性注入的方式
        /// </summary>
        public MyNameService NameService { get; set; }

        public void ShowCode()
        {
            // 默认情况下，NameService 为空，如果注入成功，则不为空
            Console.WriteLine($"MyServiceV2.ShowCode:{GetHashCode()},NameService是否为空：{NameService == null}");
        }
    }


    public class MyNameService
    { 
        
    }
}

接下来看一下如何集成 Autofac

使用 Autofac 是因为它是 .NET 社区里面最老牌的容器框架之一

它有两个包：

Autofac.Extensions.DependencyInjection

Autofac.Extras.DynamicProxy

引入这两个包，就可以使用它来达到之前说的四种能力

引入这两个包后，需要在 Program 中添加 UseServiceProviderFactory

public static IHostBuilder CreateHostBuilder(string[] args) =>
  Host.CreateDefaultBuilder(args)
      .UseServiceProviderFactory(new AutofacServiceProviderFactory())
      .ConfigureWebHostDefaults(webBuilder =>
      {
          webBuilder.UseStartup<Startup>();
      });

UseServiceProviderFactory 是用于注册第三方容器的入口

还有一个改动在 Startup 中，我们需要添加一个 ConfigureContainer 方法，它的入参是 Autofac 的 ContainerBuilder

public void ConfigureContainer(ContainerBuilder builder)
{

}

现在有两个 ConfigureServices，一个是默认的，一个是 ConfigureContainer

服务注册进默认的容器之后，实际上会被 Autofac 接替，然后执行 ConfigureContainer

Autofac 的注册方式与之前的注册方式不同，先注册具体的实现，然后再告诉它想把它标记为哪个服务的类型，与之前的写法相反

builder.RegisterType<MyService>().As<IMyService>();

接下来是命名注册，当需要把一个服务注册多次，并且用不同命名作为区分的时候，可以用这种方式，入参是一个服务名

builder.RegisterType<MyServiceV2>().Named<IMyService>("service2");

如何使用它呢？

public ILifetimeScope AutofacContainer { get; private set; }

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // 注册根容器
    this.AutofacContainer = app.ApplicationServices.GetAutofacRoot();
    
    // Autofac 容器获取实例的方式是一组 Resolve 方法
    var service = this.AutofacContainer.ResolveNamed<IMyService>("service2");
    service.ShowCode();
    
    ...

启动程序，输出如下：

MyServiceV2.ShowCode:61566768,NameService是否为空：True

如何获取没有命名的服务呢？

// Autofac 容器获取实例的方式是一组 Resolve 方法
var service = this.AutofacContainer.ResolveNamed<IMyService>("service2");
service.ShowCode();

// 获取没有命名的服务，把 namd 去掉即可
var servicenamed = this.AutofacContainer.Resolve<IMyService>();
servicenamed.ShowCode();

启动程序，输出如下：

MyServiceV2.ShowCode:44407631,NameService是否为空：True
MyService.ShowCode:61566768

接下来，讲解属性注入

// 属性注入，只需要在注册方法加上 PropertiesAutowired 即可
builder.RegisterType<MyNameService>();
builder.RegisterType<MyServiceV2>().As<IMyService>().PropertiesAutowired();

从服务里面获取它并且 ShowCode

var servicenamed = this.AutofacContainer.Resolve<IMyService>();
servicenamed.ShowCode();

启动程序，输出如下：

MyServiceV2.ShowCode:11318800,NameService是否为空：False

不为空，注册成功

接下来，演示 AOP 场景，它指的是在不期望改变原有类的情况下，在方法执行时嵌入一些逻辑，使得可以在方法执行的切面上任意插入逻辑

namespace DependencyInjectionAutofacDemo.Services
{
    /// <summary>
    /// IInterceptor 是 Autofac 的面向切面的最重要的一个接口，它可以把逻辑注入到方法的切面里面去
    /// </summary>
    public class MyInterceptor : IInterceptor
    {
        public void Intercept(IInvocation invocation)
        {
            // 方法执行前
            Console.WriteLine($"Intercept before,Method:{invocation.Method.Name}");
            // 具体方法的执行，如果这句话不执行，相当于把切面的方法拦截掉，让具体类的方法不执行
            invocation.Proceed();
            // 方法执行后，也就是说可以在任意的方法执行后，插入执行逻辑，并且决定原有的方法是否执行
            Console.WriteLine($"Intercept after,Method:{invocation.Method.Name}");
        }
    }
}

如何启动切面？

// 把拦截器注册到容器里面
builder.RegisterType<MyInterceptor>();
// 注册 MyServiceV2，并且允许它属性注册 （PropertiesAutowired）
// 开启拦截器需要使用 InterceptedBy 方法，并且注册类型 MyInterceptor
// 最后还要执行一个开关 EnableInterfaceInterceptors 允许接口拦截器
builder.RegisterType<MyServiceV2>().As<IMyService>().PropertiesAutowired().InterceptedBy(typeof(MyInterceptor)).EnableInterfaceInterceptors();

拦截器分两种类型，一种是接口拦截器，一种是类拦截器

常用的是接口拦截器，当服务类型是接口的时候，就需要使用这种方式

如果没有基于接口设计类，而是实现类的时候，就需要用类拦截器

类拦截器需要把方法设计为虚方法，这样子允许类重载的情况下，才可以拦截到具体的方法

启动程序，输出如下：

Intercept before,Method:ShowCode
MyServiceV2.ShowCode:31780825,NameService是否为空：True
Intercept after,Method:ShowCode

接下来看一下子容器的用法

// Autofac 具备给子容器进行命名的特性，可以把以服务注入到子容器中，并且是特定命名的子容器，这就意味着在其他的子容器是获取不到这个对象的
builder.RegisterType<MyNameService>().InstancePerMatchingLifetimeScope("myscope");

创建一个 myscope 的子容器

using (var myscope = AutofacContainer.BeginLifetimeScope("myscope"))
{
    var service0 = myscope.Resolve<MyNameService>();
    using (var scope = myscope.BeginLifetimeScope())
    {
        var service1 = scope.Resolve<MyNameService>();
        var service2 = scope.Resolve<MyNameService>();
        Console.WriteLine($"service1=service2:{service1 == service2}");
        Console.WriteLine($"service1=service0:{service1 == service0}");
    }
}

启动程序，输出如下：

service1=service2:True
service1=service0:True

这意味着在 myscope 子容器下面，不管再创建任何子容器的生命周期，得到的都是同一个对象

这样子的好处是当不期望这个对象在根容器创建时，又希望它在某一定的范围内时单例模式的情况下，可以使用这种方式

GitHub源码链接：https://github.com/MingsonZheng/DotNetCoreDevelopmentActualCombat/tree/main/DependencyInjectionAutofacDemo