最近有个需求就是一个抽象仓储层接口方法需要SqlServer以及Oracle两种实现方式，为了灵活我在依赖注入的时候把这两种实现都给注入进了依赖注入容器中，但是在服务调用的时候总是获取到最后注入的那个方法的实现，这时候就在想能不能实现动态的选择使用哪种实现呢？如果可以的话那么我只需要在配置文件中进行相应的配置即可获取到正确的实现方法的调用，这样的话岂不快哉！今天我们就来一起探讨下实现这种需求的几种实现方式吧。

作者：依乐祝
原文地址：https://www.cnblogs.com/yilezhu/p/10236163.html

代码演示

在开始实现的方式之前，我们先模拟下代码。由于真实系统的结构比较复杂，所以这里我就单独建一个类似的项目结构代码。项目如下图所示：

接下来我来详细说下上面的结果作用及代码。

1. MultiImpDemo.I 这个项目是接口项目，里面有一个简单的接口定义ISayHello，代码如下：

       public interface ISayHello
       {
           string Talk();
       }

   很简单，就一个模拟讲话的方法。

2. MultiImpDemo.A 这个类库项目是接口的一种实现方式，里面有一个SayHello类用来实现ISayHello接口,代码如下：

   /**
   *┌──────────────────────────────────────────────────────────────┐
   *│　描    述：
   *│　作    者：yilezhu
   *│　版    本：1.0
   *│　创建时间：2019/1/7 17:41:33
   *└──────────────────────────────────────────────────────────────┘
   *┌──────────────────────────────────────────────────────────────┐
   *│　命名空间： MultiImpDemo.A
   *│　类    名： SayHello
   *└──────────────────────────────────────────────────────────────┘
   */
   using MultiImpDemo.I;
   using System;
   using System.Collections.Generic;
   using System.Text;
   
   namespace MultiImpDemo.A
   {
       public class SayHello : ISayHello
       {
           public string Talk()
           {
               return "Talk from A.SayHello";
           }
       }
   }

3. MultiImpDemo.B 这个类库项目是接口的另一种实现方式，里面也有一个SayHello类用来实现ISayHello接口,代码如下：

   /**
   *┌──────────────────────────────────────────────────────────────┐
   *│　描    述：
   *│　作    者：yilezhu
   *│　版    本：1.0
   *│　创建时间：2019/1/7 17:41:45
   *└──────────────────────────────────────────────────────────────┘
   *┌──────────────────────────────────────────────────────────────┐
   *│　命名空间： MultiImpDemo.B
   *│　类    名： SayHello
   *└──────────────────────────────────────────────────────────────┘
   */
   using MultiImpDemo.I;
   using System;
   using System.Collections.Generic;
   using System.Text;
   
   namespace MultiImpDemo.B
   {
       public class SayHello:ISayHello
       {
           public string Talk()
           {
               return "Talk from B.SayHello";
           }
       }
   }
   

4. MultiImpDemo.Show 这个就是用来显示我们模拟效果的API项目，首选我们在ConfigureServices中加入如下的代码来进行上述两种实现方式的注入：

    services.AddTransient<ISayHello, MultiImpDemo.A.SayHello>();
    services.AddTransient<ISayHello, MultiImpDemo.B.SayHello>();

5. 在api实现里面获取服务并进行模拟调用：

     private readonly ISayHello sayHello;
   
           public ValuesController(ISayHello sayHello)
           {
               this.sayHello = sayHello;
           }
   
           // GET api/values
           [HttpGet]
           public ActionResult<IEnumerable<string>> Get()
           {
               return new string[] { sayHello.Talk() };
           }
   

   代码很简单对不对？你应该看的懂吧，这时候我们运行起来项目，然后访问API'api/values'这个接口，结果总是显示如下的结果：

   

两种需求对应两种实现

这里有两种业务需求！第一种业务中只需要对其中一种实现方式进行调用，如：业务需要SqlServer数据库的实现就行了。第二种是业务中对这两种实现方式都有用到，如：业务急需要用到Oracle的数据库实现同时也有用到SqlServer的数据库实现，需要同时往这两个数据库中插入相同的数据。下面分别对这两种需求进行解决。

业务中对这两种实现方式都有用到

针对这种情况有如下两种实现方式：

1. 第二种实现方式

   其实，在ASP.NET Core中，当你对一个接口注册了多个实现的时候，构造函数是可以注入一个该接口集合的，这个集合里是所有注册过的实现。

   下面我们先改造下ConfigureServices,分别注入下这两种实现

   services.AddTransient<ISayHello, A.SayHello>();
   services.AddTransient<ISayHello,B.SayHello>();

   接着继续改造下注入的方式，这里我们直接注入IEnumerable<ISayHello>如下代码所示：

   private readonly ISayHello sayHelloA;
           private readonly ISayHello sayHelloB;
           public ValuesController(IEnumerable<ISayHello> sayHellos)
           {
               sayHelloA = sayHellos.FirstOrDefault(h => h.GetType().Namespace == "MultiImpDemo.A");
               sayHelloB = sayHellos.FirstOrDefault(h => h.GetType().Namespace == "MultiImpDemo.B");
           }
   
           // GET api/values
           [HttpGet]
           public ActionResult<IEnumerable<string>> Get()
           {
               return new string[] { sayHelloA.Talk() , sayHelloB.Talk()};
           }
   

   然后运行起来看下效果吧

   

2. 利用AddTransient的扩展方法public static IServiceCollection AddTransient<TService>(this IServiceCollection services, Func<IServiceProvider, TService> implementationFactory) where TService : class;然后根据我们的配置的实现来进行服务实现的获取。下面就让我们利用代码来实现一番吧：

     services.AddTransient<A.SayHello>();
               services.AddTransient<B.SayHello>();
   
               services.AddTransient(implementationFactory =>
               {
                   Func<string, ISayHello> accesor = key =>
                   {
                       if (key.Equals("MultiImpDemo.A"))
                       {
                           return implementationFactory.GetService<A.SayHello>();
                       }
                       else if (key.Equals("MultiImpDemo.B"))
                       {
                           return implementationFactory.GetService<B.SayHello>();
                       }
                       else
                       {
                           throw new ArgumentException($"Not Support key : {key}");
                       }
                   };
                   return accesor;
               });
   

   当然了，既然用到了我们配置文件中的代码，因此我们需要设置下这个配置：

   然后我们具体调用的依赖注入的方式需要变化一下：

   private readonly ISayHello sayHelloA;
           private readonly ISayHello sayHelloB;
   
           private readonly Func<string, ISayHello> _serviceAccessor;
   
           public ValuesController(Func<string, ISayHello> serviceAccessor)
           {
               this._serviceAccessor = serviceAccessor;
   
               sayHelloA = _serviceAccessor("MultiImpDemoA");
               sayHelloB = _serviceAccessor("MultiImpDemoB");
           }
   
           // GET api/values
           [HttpGet]
           public ActionResult<IEnumerable<string>> Get()
           {
               return new string[] { sayHelloA.Talk() , sayHelloB.Talk()};
           }

   然后运行看下效果吧：

   

   可以看到A跟B的实现都获取到了！效果实现！

业务只需要对其中一种实现方式的调用

这时候我们可以根据我们预设的配置来动态获取我们所需要的实现。这段话说的我自己都感觉拗口。话不多少，开鲁吧！这里我将介绍三种实现方式。

1. 根据我们的配置文件中设置的key来进行动态的注入。

   这种方式实现之前首先得进行相应的配置，如下所示：

     "CommonSettings": {
       "ImplementAssembly": "MultiImpDemo.A"
     }

   然后在注入的时候根据配置进行动态的进行注入：

    services.AddTransient<ISayHello, A.SayHello>();
               services.AddTransient<ISayHello, B.SayHello>();

   然后在服务调用的时候稍作修改：

     private readonly ISayHello sayHello;
           public ValuesController(IEnumerable<ISayHello> sayHellos,IConfiguration configuration)
           {
               sayHello = sayHellos.FirstOrDefault(h => h.GetType().Namespace == configuration.GetSection("CommonSettings:ImplementAssembly").Value);
           }
   
           // GET api/values
           [HttpGet]
           public ActionResult<IEnumerable<string>> Get()
           {
               return new string[] { sayHello.Talk() };
           }

   OK,到这里运行一下看下效果吧！然后改下配置文件再看下效果！

   

2. 第二种实现方式，即接口参数的方式这样可以避免上个方法中反射所带来的性能损耗。

   这里我们改造下接口，接口中加入一个程序集的属性，如下所示：

   public interface ISayHello
       {
           string ImplementAssemblyName { get; }
           string Talk();
       }

   对应的A跟B中的实现代码也要少做调整：

   A:

    public string ImplementAssemblyName => "MultiImpDemo.A";
   
           public string Talk()
           {
               return "Talk from A.SayHello";
           }

   B:

    public string ImplementAssemblyName => "MultiImpDemo.B";
   
           public string Talk()
           {
               return "Talk from B.SayHello";
           }

   然后，在实现方法调用的时候稍微修改下：

    private readonly ISayHello sayHello;
           public ValuesController(IEnumerable<ISayHello> sayHellos,IConfiguration configuration)
           {
               sayHello = sayHellos.FirstOrDefault(h => h.ImplementAssemblyName == configuration.GetSection("CommonSettings:ImplementAssembly").Value);
           }
   
           // GET api/values
           [HttpGet]
           public ActionResult<IEnumerable<string>> Get()
           {
               return new string[] { sayHello.Talk() };
           }
   

   效果自己运行下看下吧！

3. 第三种实现是根据配置进行动态的注册

   首先修改下ConfigureServices方法：

    var implementAssembly = Configuration.GetSection("CommonSettings:ImplementAssembly").Value;
               if (string.IsNullOrWhiteSpace(implementAssembly)) throw new ArgumentNullException("CommonSettings:ImplementAssembly未配置");
               if (implementAssembly.Equals("MultiImpDemo.A"))
               {
                   services.AddTransient<ISayHello, A.SayHello>();
   
               }
               else
               {
                   services.AddTransient<ISayHello, B.SayHello>();
   
               }

   这样的话就会根据我们的配置文件来进行动态的注册，然后我们像往常一样进行服务的调取即可：

     private readonly ISayHello _sayHello;
           public ValuesController(ISayHello sayHello)
           {
               _sayHello = sayHello;
           }
   
           // GET api/values
           [HttpGet]
           public ActionResult<IEnumerable<string>> Get()
           {
               return new string[] { _sayHello.Talk() };
           }

   运行即可得到我们想要的效果！

总结

本文从具体的业务需求入手，根据需求来或动态的进行对应服务的获取，或同时使用两个不同的实现！希望对您有所帮助！如果您有更多的实现方法可以在下方留言，或者加入.NET Core实战千人群跟637326624大伙进行交流，最后感谢您的阅读！