.NET依赖注入之一个接口多个实现

前言

最近又在项目中碰到需要将原本单实现的接口改造成多个实现的场景，这里记录一下常见的几种改法。
假设已经存在如下接口ICustomService和其实现CustomService，由于只有一种实现，注入和使用非常容易。

1. public interface ICustomService
2. {
3.     void MethodA();
4.     void MethodB();
5. }
6. public class CustomService: ICustomService
7. {
8.     public void MethodA()
9.     {
10.     }
12.     public void MethodB()
13.     {
14.     }
15. }
17. //注入
18. builder.Services.AddTransient<ICustomService, CustomService>();
20. //使用
21. private readonly ICustomService _customService;
22. public CustomController(ICustomService customService)
23. {
24.   _customService = customService;
25. }

复制代码

现在我们需要增加一种实现。
使用多个接口实现

我们可以将原ICustomService内的方法移到到一个新的基接口，共享出来，需要多少个实现，就创建多少个空接口继承该基接口。

1. //基接口
2. public interface ICustomBaseService
3. {
4.     void MethodA();
5.     void MethodB();
6. }
8. //多个空接口
9. public interface ICustomService : ICustomBaseService
10. {
11. }
13. public interface ICustomServiceV2 : ICustomBaseService
14. {
15. }
17. //第一种实现
18. public class CustomService: ICustomService
19. {
20.     public void MethodA()
21.     {
22.     }
24.     public void MethodB()
25.     {
26.     }
27. }
29. //第二种实现
30. public class CustomServiceV2: ICustomServiceV2
31. {
32.     public void MethodA()
33.     {
34.     }
36.     public void MethodB()
37.     {
38.     }
39. }
41. //注入
42. builder.Services.AddTransient<ICustomService, CustomService>();
43. builder.Services.AddTransient<ICustomServiceV2, CustomServiceV2>();
46. //使用
47. private readonly ICustomService _customService;
48. private readonly ICustomServiceV2 _customServiceV2;
49. public CustomController(ICustomService customService,ICustomServiceV2 customServiceV2)
50. {
51.   _customService = customService;
52.   _customServiceV2 = customServiceV2;
53. }

复制代码

这种实现方式需要增加了一套空接口做隔离，看似可能比较“浪费”，但后期随着项目的演进，ICustomService和ICustomServiceV2可能会慢慢分化，我们可以很方便的为它们扩充各种独有方法。
使用单接口实现

如果我们确定不要要多个接口，也可以使用下面的单接口实现

1. public interface ICustomService
2. {
3.     void MethodA();
4.     void MethodB();
5. }
7. //第一种实现
8. public class CustomService: ICustomService
9. {
10.     public void MethodA()
11.     {
12.     }
14.     public void MethodB()
15.     {
16.     }
17. }
19. //第二种实现
20. public class CustomServiceV2: ICustomService
21. {
22.     public void MethodA()
23.     {
24.     }
26.     public void MethodB()
27.     {
28.     }
29. }
31. //注入
32. builder.Services.AddTransient<ICustomService, CustomService>();
33. builder.Services.AddTransient<ICustomService, CustomServiceV2>();
36. //使用
37. private readonly ICustomService _customService;
38. private readonly ICustomServiceV2 _customServiceV2;
39. public CustomController(IEnumerable<ICustomService> customServices)
40. {
41. _customService = customServices.ElementAt(0);
42. _customServiceV2 = customServices.ElementAt(1);
43. }

复制代码

从上面代码可以看到，我们是为从接口ICustomService注册两个实现，并从IEnumerable解析出了这两个实现。这里可能会有两个疑问

• 为什么第一个实现CustomService没有被第二个实现CustomServiceV2替换掉？
  
• 为什么可以从IEnumerable解析到我们需要的服务？
  

答案在Microsoft.Extensions.DependencyInjection.ServiceDescriptor 和 Microsoft.Extensions.DependencyInjection.ServiceCollection 这两个类里，进程里，依赖注入的服务，会被添加到ServiceCollection里，ServiceCollection是一组ServiceDescriptor的集合，ServiceDescriptor通过服务类型、实现以及生命周期三个组合在一起构成的标识来确定服务。而ICustomService+CustomService+Transient和ICustomService+CustomServiceV2+Transient是两个不同的ServiceDescriptor，因此不会被替换。同时服务类型的ServiceDescriptor会被聚合在一起，于是我们可以很方便的从IEnumerable对象中解析出所有的同类型的服务。
总结

本质上，两种方法都是多态性（Polymorphism）的应用，没有优劣之分，根据场景选择合适的写法。
链接

https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection
https://github.com/dotnet/runtime

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！