【.NET Core 3.0】小技巧 || 原生DI一对多注入

老张的哲学

发布于 2022-04-11 08:21:44

3580

发布于 2022-04-11 08:21:44

文章被收录于专栏：NetCore 从壹开始

本文是一个技巧文章，内容很短，但是被提问的频率很高，所以记录下来，以待大家不时之需。

以下的代码，是通过原生的依赖注入来讲解的，其他的第三方框架，可以自己自定义扩展，效果是一样的，那咱们先来回顾下依赖注入，都有哪几种情况。

一、依赖注入有哪几种情况

关于依赖注入，其实我已经写了很多的文章，也录了很多的视频了，这里就不过多的解析什么了，无论是原理，还是好处，甚至是使用场景等等，如果你还不是很了解，可以看看我的视频。

https://www.bilibili.com/video/av58096866?p=5

https://www.bilibili.com/video/av73194514

上边的这个是基础和核心知识点，下边的是我直播的时候，手写的代码，可以根据自己的需要去查看。

总体来说，我一直讲的依赖注入的方式，都是面向抽象的 很常见的：一个类对应一个接口。那还有其他的注入情况么？当然还有很多，比如：

1、单独的一个类注入； 2、一个类继承了多个接口； 3、一个接口有多个实现类；

当然，除了上边这三个，还有单独类的 AOP 操作等等，一个类对应一个接口的情况，我们已经说了很多了，这里就不说了，一个类多个接口的，这个也不用说，其实就和一个类对应一个接口，是一个效果，那我们就先说说注入单独的一个类和，一个接口对应多个实现，这两种情况吧。

单独注入一个类很简单，大家都知道，依赖注入，其实就是实例化的过程，然后管理我们的对象的生命周期，降低耦合等等多个好处。

那我们既然是实例化的过程，简单啊，放到容器，直接使用它！

 /// <summary>
 /// 1、定义一个单独类，不继承任何
 /// </summary>
 public class OneSeparateService
 {
     /// <summary>
     /// 写一个方法，可以通过类型返回不同内容
     /// </summary>
     /// <param name="type"></param>
     /// <returns></returns>
     public string SayHello(string type="") {

         if (type == "English")
         {
             return "Hello";
         }
         else { 
             return "你好";
         }
     }
 }

// 2、注入容器
services.AddScoped<OneSeparateService>();

/// <summary>
/// 3、构造函数注入
/// </summary>
/// <param name="oneSeparateService"></param>
public WeatherForecastController(OneSeparateService oneSeparateService)
{
    _oneSeparateService = oneSeparateService;
}


 // 4、调用
 [HttpGet]
 public object Get()
 {
     // 依赖注入，就等于下边的直接new一个实例
     //OneSeparateService oneSeparateService = new OneSeparateService(); 
     return oneSeparateService.SayHello("English");
 }

我们只需要直接构造函数注入，即可使用，有种静态方法的意味，是不是很简单！当然很简单啦，因为今天我们不是说这个的，说这个仅仅是一个开胃菜，体会一下注入的过程而已。

好啦，热身完成，下面，我们就详细的说说如何实现一个接口多个实现类吧。

二、如何注入一对多

既然说到了一对多，那现在我们就来模式一下数据：

 /// <summary>
 /// 1、定义一个接口
 /// </summary>
 public interface IMoreImplService
 {
     string SayWelocome();
 }
 
 /// <summary>
 /// 2、分别定义两个实现类
 /// </summary>
 public class WelcomeChineseService : IMoreImplService
 {
     public string SayWelocome()
     {
         return "欢迎";
     }
 }

 public class WelcomeEnglishService : IMoreImplService
 {
     public string SayWelocome()
     {
         return "Welcome";
     }
 }

然后我们准备好了，该注入了，你可能会说，简单呀！直接注入然后调用不就好了：

services.AddScoped<IMoreImplService, WelcomeChineseService>();
services.AddScoped<IMoreImplService, WelcomeEnglishService>();

然后直接调用

  public WeatherForecastController(IMoreImplService moreImplService)
  {
      _moreImplService = moreImplService;
  }

  [HttpGet]
  public object Get()
  {
      return _moreImplService.SayWelocome();
  }

这个时候，是不是有点儿懵，嗯？那我现在到底调用的是哪个实现类呀，我们运行看看效果就知道了：

可以看到是 Welcome ，正好和我们的注入顺序是一致的，就是说，无论注入多少个，最终是最后一个生效，就好像 = new () 了好几次，把之前的实例给覆盖了一样，你应该懂了吧，不信的话，可以把注入的顺序换换，就知道啦。

请记住，刚刚我用的是好像字眼，真的是被覆盖掉了么，我们来看看就知道了，既然是注入了多个，我们就把多个实例都拿出来：

 /// <summary>
 /// 1、将多个接口实例关系全部注入
 /// </summary>
 /// <param name="moreImplServices"></param>
 public WeatherForecastController(IEnumerable<IMoreImplService> moreImplServices)
 {
     // 注意这里是复数
     _moreImplServices = moreImplServices;
 }

 [HttpGet]
 public object Get()
 {
     var result = "";
     // 调用多次输出
     foreach (var item in _moreImplServices)
     {
         result += item.SayWelocome() + "\n";
     }

     return result;
 }

详细这个时候，你应该猜得出来答案了吧：

把两个实例都打印了出来，这就说明一个问题，我们在容器里，并不是在注入的时候，后来的把前边的给覆盖掉了，而是 本来容器里就有多个接口实例映射关系 ，只是我们在 controller 控制器里取的时候，只获取了最后一个而已！

那明白了这个问题，我们就很开心了，容器里还是都有的，我们还是可以按照我们的需要，取出想要的某一个，那我们就猜想了，如何区分呢，在文章开头，我们定义方法的时候，就是想着用一个 type ，那这里我们能不能用一个别名来做区分呢，欸，重头戏来了：

 /// <summary>
 /// 定义一个服务工厂,Singleton注入
 /// 注意这个不是真正意义上的工厂，只是提供服务的存取
 /// </summary>
 public class SingletonFactory
 {
     // 定义一个字典,存储我们的接口服务和别名
     Dictionary<Type, Dictionary<string, object>> serviceDict;
     public SingletonFactory()
     {
         serviceDict = new Dictionary<Type, Dictionary<string, object>>();
     }

     /// <summary>
     /// 根据别名,获取接口实例
     /// </summary>
     /// <typeparam name="TService"></typeparam>
     /// <param name="id"></param>
     /// <returns></returns>
     public TService GetService<TService>(string id) where TService : class
     {
         // 获取接口的类型
         var serviceType = typeof(TService);
         // out 方法,先获取某一个接口下的,<别名,实例>字典
         if (serviceDict.TryGetValue(serviceType, out Dictionary<string, object> implDict))
         {
             // 根据别名,获取接口的实例对象
             if (implDict.TryGetValue(id, out object service))
             {
                 // 强类型转换
                 return service as TService;
             }
         }
         return null;
     }

   
     /// <summary>
     /// 将实例和别名 匹配存储
     /// </summary>
     /// <typeparam name="TService"></typeparam>
     /// <param name="service"></param>
     /// <param name="id"></param>
     public void AddService<TService>(TService service, string id) where TService : class
     {
         var serviceType = typeof(TService);
         // 对象实例判空
         if (service != null)
         {
             // 如果不存在,则填充
             if (serviceDict.TryGetValue(serviceType, out Dictionary<string, object> implDict))
             {
                 implDict[id] = service;
             }
             else
             {
                 implDict = new Dictionary<string, object>();
                 implDict[id] = service;
                 serviceDict[serviceType] = implDict;
             }
         }
     }
 }

上边的代码相信应该能大致看的明白，看不明白也没关系，主要一句话概括，就是使用了一个服务，维护一个字典，利用泛型，先把对象实例和别名，分配存储到字典，然后再根据别名或者指定接口的对象实例，

就是把接口下的实现类，都 new 出来实例，然后匹配上别名，说白了，就是我们的 type，然后再输出出来。

那下一步，我们就需要先把这个单例服务给注入进去：

 SingletonFactory singletonFactory = new SingletonFactory();
 singletonFactory.AddService<IMoreImplService>(new WelcomeChineseService(), "Chinese");
 singletonFactory.AddService<IMoreImplService>(new WelcomeEnglishService(), "English");

 services.AddSingleton(singletonFactory);

这个应该都能看的懂，唯一的小问题，可能会问，为啥要把我们的 singletonFactory 给 Singleton 注入？

因为我这是一个对象实例，只能是单例了，而且里边的多个服务因为已经new实例过了，所以没办法控制生命周期。

最后我们就来调用看看：

// 各自定义需要的多个字段
private readonly IMoreImplService moreImplServiceChinese;
private readonly IMoreImplService moreImplServiceEnglish;


public WeatherForecastController(SingletonFactory singletonFactory)
{
    this.singletonFactory = singletonFactory;

    // 根据别名获取服务
    moreImplServiceChinese = singletonFactory.GetService<IMoreImplService>("Chinese");
    moreImplServiceEnglish = singletonFactory.GetService<IMoreImplService>("English");
}

[HttpGet("/welcome")]
public object GetWelcome()
{
    return moreImplServiceChinese.SayWelocome();
}

结果我们不用看了，已经成功了，最后我们再来回顾一下这种写法的步骤：

1、定义一个单例服务类，将我们的多个对象new出来实例，和别名对应存储起来； 2、将单例类实例化后，注入服务容器； 3、控制器获取单例类，并根据别名获取相对应的服务；

到了这里，我们就已经完成了，是不是到了这里，感觉是已经完成了，但是又感觉哪里不是很舒服，比如这样注入的实例都是单例的，那这样不是很合适呀？

三、简单工厂模式注入【推荐】

如何才能适应不同的生命周期呢，我这里提供第二个方法：

 // 先把多个实现类服务注入进去
 services.AddScoped<WelcomeChineseService>();
 services.AddScoped<WelcomeEnglishService>();

 // 然后通过简单工厂模式，针对不同的 key 来获取指定的对象实例
 services.AddScoped(factory =>
 {
     Func<string, IMoreImplService> accesor = key =>
     {
         if (key.Equals("Chinese"))
         {
             // 因为这里是从容器获取服务实例的，所以我们可以控制生命周期
             return factory.GetService<WelcomeChineseService>();
         }
         else if (key.Equals("English"))
         {
             return factory.GetService<WelcomeEnglishService>();
         }
         else
         {
             throw new ArgumentException($"Not Support key : {key}");
         }
     };
     return accesor;
 });

大家可以看一下，我们用的是 Scope 方式注入的，三种生命周期都可以，接下看就是调用了：

 // 将我们的规则 Func 构造函数注入
 private readonly Func<string, IMoreImplService> _serviceAccessor;

 public WeatherForecastController(Func<string, IMoreImplService> serviceAccessor)
 {
     // 获取特定接口的服务访问器，然后根据别名获取
     _serviceAccessor = serviceAccessor;
     // 这里的别名，你可以配置到 appsetting.json 文件里，动态的修改获取对象实例
     // 然后再在接口中配置一个字段 string ImplementKeyName { get; }
     moreImplServiceChinese = _serviceAccessor("Chinese");
     moreImplServiceEnglish = _serviceAccessor("English");
 }


 [HttpGet("/welcome")]
 public object GetWelcome()
 {
     return moreImplServiceChinese.SayWelocome() + "\n" + moreImplServiceEnglish.SayWelocome();
 }

为了演示效果，我把Service服务的构造函数，增加一个动态时间，来判断是否满足Scope需求，那现在我们就来看看效果吧：

 public class WelcomeChineseService : IMoreImplService
 {
     public DateTime Now { get; set; }
     public WelcomeChineseService()
     {
         Now = DateTime.Now;
     }
     public string SayWelocome()
     {
         return "欢迎" + Now;
     }
 }