ASP.NET Core 依赖注入基础测试题

太过爱你忘了你带给我的痛 2021-06-26 16:06 460阅读 0赞

作为一名 ASP.NET Core 的开发者，依赖注入可以说是居家旅行开发调试的必备技能。  
在这篇文章里，希望通过一些常识性测试题，来巩固学习一下依赖注入的基础知识。

## 作用域 ##

请问下面这段代码的执行结果是什么？

public interface IServiceA {  }
    
    class ServiceA : IServiceA
    { 
        ServiceA()
        { 
            Console.WriteLine("New SA");
        }
    }
    
    public class Startup
    { 
        public void ConfigureServices(IServiceCollection services)
        { 
            services.AddTransient<IServiceA, ServiceA>();
            ...
        }
    }

结果是报错：

System.AggregateException: 'Some services are not able to be constructed'
    A suitable constructor for type 'AspNetCore.Services.ServiceA' could not be located.
    Ensure the type is concrete and services are registered for all parameters of a public constructor.

官方文档在 [Constructor injection behavior][] 有提过，如果通过构造函数注入，构造函数必须是 `public` 级别。

为什么 `constructor` 要 `public` 呢？因为默认的访问级别是 `private`。依赖注入是由 `ASP.NET Core` 实现的，自然是无法访问 `private` 级别的构造方法的。

那 `class` 需不需要是 `public` 呢？不需要，因为通过方法调用的方式已经让 `DI` 获取到了 `class`，如果是 `using namespace` 的情况下访问 `class`，才需要 `class` 也是 `public`。

## 生命周期 ##

下面这段代码中，`singleton` 的 `IServiceA` 被 `HelloController` 所依赖，在项目启动之后，没有访问网页的情况下，`ServiceA` 会被初始化吗？

public interface IServiceA {  }
    
    public class ServiceA : IServiceA
    { 
        public ServiceA()
        { 
            Console.WriteLine("New SA");
        }
    }
    public class Startup
    { 
        public void ConfigureServices(IServiceCollection services)
        { 
            services.AddSingleton<IServiceA, ServiceA>();
            ...
        }
    }
    public class HelloController : ControllerBase
    { 
        public WeatherForecastController(IServiceA sa)
        { 
            Console.WriteLine($"Test Controller: { sa.GetType()}");
        }
    }

`ServiceA` 并不会被初始化。DI 虽然会检查是否存在 `public constructor` ，但是不会立即初始化服务实例，只有在服务被使用的时候才会根据注册时的生命周期做初始化。`ServiceA` 只被 `controller` 依赖，而 `controller` 只有在请求过来的时候才会被初始化：  
![在这里插入图片描述][20210615204924707.png]  
所以 `ServiceA` 也只有在请求到达 `controller` 的时候才会跟着 `controller` 一起被初始化。

如果连续访问三次 `controller`，会看到 `singleton` 在第一次请求到达时被初始化，后面传入的都还是以前的实例：

New SA
    Test Controller: AspNetCore.Services.ServiceA
    Test Controller: AspNetCore.Services.ServiceA
    Test Controller: AspNetCore.Services.ServiceA

如果我们用 `AddScoped` 或者 `AddTrancient`，每次访问 `API` 都会看到 `ServiceA` 被初始化了：

New SA
    Test Controller: AspNetCore.Services.ServiceA
    New SA
    Test Controller: AspNetCore.Services.ServiceA
    New SA
    Test Controller: AspNetCore.Services.ServiceA

## 依赖后的生命周期 ##

如果 `ServiceA` 是 `transient` 的，`ServiceB` 是 `singleton` 的，`ServiceB` 和 `controller` 都依赖 `ServiceA`，请问第一次访问 `controller` 的路由，`ServiceA` 会被初始化几次？第二次访问呢？

public interface IServiceA {  }
    public class ServiceA : IServiceA
    { 
        public ServiceA()
        { 
            Console.WriteLine("New SA");
        }
    }
    
    public interface IServiceB {  }
    public class ServiceB : IServiceB
    { 
        public ServiceB(IServiceA sa)
        { 
            Console.WriteLine("New SB");
        }
    }
    
    public class Startup
    { 
        public void ConfigureServices(IServiceCollection services)
        { 
            services.AddTransient<IServiceA, ServiceA>();
            services.AddSingleton<IServiceB, ServiceBz>();
            ...
        }
    }
    public class HelloController : ControllerBase
    { 
        public WeatherForecastController(IServiceA sa, IServiceB sb)
        { 
            Console.WriteLine($"Test Controller: { sa.GetType()} { sb.GetType()}");
        }
    }

第一次访问输出结果：

New SA
    New SA
    New SB
    Test Controller: AspNetCore.Services.ServiceA AspNetCore.Services.ServiceB
    New SA
    Test Controller: AspNetCore.Services.ServiceA AspNetCore.Services.ServiceB

可以看到，`ServiceA` 因为是 `transient` 的，所以每次请求都会被初始化一次。而 `ServiceB` 是 `singleton` 的，虽然它依赖一个 `transient` 的 `ServiceA`，但是初始化之后就不会再传入新的 `ServiceA` 了，在 `singleton` 的 `ServiceB` 中的 `ServiceA` 也是 `singleton` 的。

如果在 `transient` 的 `ServiceA` 中依赖一个 `singleton` 的 `ServiceB` 呢？

New SB
    New SA
    Test Controller: AspNetCore.Services.ServiceA AspNetCore.Services.ServiceB
    New SA
    Test Controller: AspNetCore.Services.ServiceA AspNetCore.Services.ServiceB

`singleton` 的 `ServiceB` 不管在哪里取出，都是 `singleton` 的，虽然 `ServiceA` 和 `controller` 在多个请求中做了多次初始化，但是传入的都是同一个 `ServiceB` 实例。

## 多个依赖的初始化顺序 ##

如果注册的时候是先 A 后 B，`constructor` 里是先 B 后 A，哪个会先被初始化？

public interface IServiceA {  }
    public class ServiceA : IServiceA
    { 
        public ServiceA()
        { 
            Console.WriteLine("New SA");
        }
    }
    
    public interface IServiceB {  }
    public class ServiceB : IServiceB
    { 
        public ServiceB()
        { 
            Console.WriteLine("New SB");
        }
    }
    
    public class Startup
    { 
        public void ConfigureServices(IServiceCollection services)
        { 
            services.AddSingleton<IServiceA, ServiceA>();
            services.AddSingleton<IServiceB, ServiceB>();
            ...
        }
    }
    
    public class HelloController : ControllerBase
    { 
        public WeatherForecastController(IServiceB sb, IServiceA sa)
        { 
            Console.WriteLine($"Test Controller: { sa.GetType()}");
        }
    }

输出结果：

New SB
    New SA
    Test Controller: AspNetCore.Services.ServiceA AspNetCore.Services.ServiceB

虽然注入依赖的顺序是 `AB` ，但是因为调用顺序是 `BA`，所以会先初始化 `B` 再初始化 `A`

如果 B 的构造函数依赖了 A 呢？

public class ServiceB : IServiceB
    { 
        public ServiceB(IServiceA sa)
        { 
            Console.WriteLine($"New SB with sa:{ sa.GetType()}");
        }
    }

输出结果：

New SA
    New SB with sa:AspNetCore.Services.ServiceA
    Test Controller: AspNetCore.Services.ServiceA AspNetCore.Services.ServiceB

此时会先把被依赖的 `ServiceA` 初始化完成再继续初始化 `ServiceB`。

如果依赖注入的时候是先注入 `B` 再注入 `A` 呢？

public void ConfigureServices(IServiceCollection services)
    { 
        services.AddScoped<IServiceB, ServiceB>();
        services.AddScoped<IServiceA, ServiceA>();
    }

输出结果：

New SA
    New SB with sa:AspNetCore.Services.ServiceA
    Test Controller: AspNetCore.Services.ServiceA AspNetCore.Services.ServiceB

依赖注入的声明顺序并不重要，`DI Container` 会存储下 `interface` 和 `class` 的映射关系，在初始化的时候会根据依赖关系妥善处理。

## 一个接口多种实现 ##

如果一个 `interface` 有多个实现类，并且都进行了注入，在 `constructor` 取出这个 `interface` 的时候会取到哪一个？多个实现类是否都会被初始化？

public interface IServiceA {  }
    public class ServiceA : IServiceA
    { 
        public ServiceA()
        { 
            Console.WriteLine("New SA");
        }
    }
    public class ServiceB : IServiceA
    { 
        public ServiceB()
        { 
            Console.WriteLine("New SB");
        }
    }
    
    public class Startup
    { 
        public void ConfigureServices(IServiceCollection services)
        { 
            services.AddSingleton<IServiceA, ServiceA>();
            services.AddSingleton<IServiceA, ServiceB>();
            ...
        }
    }
    
    public class HelloController : ControllerBase
    { 
        public WeatherForecastController(IServiceA sa)
        { 
            Console.WriteLine($"Test Controller: { sa.GetType()}");
        }
    }

输出结果：

New SB
    Test Controller: AspNetCore.Services.ServiceB

一个接口多个实现，只会取出最后的一个实现来构造实例。其他实现类的构造方法不会被调用。`DI Container` 在存好 `interface` 和 `class` 的映射关系后，如果有新的实现就会覆盖掉前面的映射。

## 多个接口一个实现 ##

如果一个接口有多个实现，并且都进行了单例的依赖注入，在取出实例的时候会被初始化几次？

public interface IServiceA {  }
    public interface IServiceB {  }
    public class ServiceB : IServiceA, IServiceB
    { 
        public ServiceB()
        { 
            Console.WriteLine("New SB");
        }
    }
    
    public class Startup
    { 
        public void ConfigureServices(IServiceCollection services)
        { 
            services.AddSingleton<IServiceA, ServiceB>();
            services.AddSingleton<IServiceB, ServiceB>();
            ...
        }
    }
    
    public class HelloController : ControllerBase
    { 
        public WeatherForecastController(IServiceA sa, IServiceB sb)
        { 
            Console.WriteLine($"Test Controller: { sa.GetType()} { sb.GetType()}");
        }
    }

输出结果：

New SB
    New SB
    Test Controller: AspNetCore.Services.ServiceB AspNetCore.Services.ServiceB

可以看到，`AddSingleton` 是针对 `interface` 的单例，而不是实现类的单例。对于 `DI` 来说，`ServiceB` 是对两种 `interface` 的实现类，会分别进行初始化。

## 后续 ##

这些问题都是比较基础的依赖注入问题，希望对于依赖注入的学习起到抛砖引玉的作用。其中的一些理解分析也只是个人观点，如果有错误的地方欢迎指出。

[Constructor injection behavior]: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-3.1#constructor-injection-behavior
[20210615204924707.png]: /images/20210626/7f9be10af560481495fd0dde49c3bb6d.png