.NET Core中的一个接口多种实现的依赖注入与动态选择看这篇就够了

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

做者：依乐祝
原文地址：http://www.javashuo.com/article/p-vjzpklwc-ez.html数据库

代码演示

在开始实现的方式以前，咱们先模拟下代码。因为真实系统的结构比较复杂，因此这里我就单独建一个相似的项目结构代码。项目以下图所示：c#

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

MultiImpDemo.I 这个项目是接口项目，里面有一个简单的接口定义ISayHello，代码以下：markdown
```
public interface ISayHello
    {
        string Talk();
    }
```
很简单，就一个模拟讲话的方法。ide

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";
        }
    }
}

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

/**
*┌──────────────────────────────────────────────────────────────┐
*│　描    述：                                                    
*│　做    者：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";
        }
    }
}

MultiImpDemo.Show 这个就是用来显示咱们模拟效果的API项目，首选咱们在ConfigureServices中加入以下的代码来进行上述两种实现方式的注入：性能
```
services.AddTransient<ISayHello, MultiImpDemo.A.SayHello>();
 services.AddTransient<ISayHello, MultiImpDemo.B.SayHello>();
```

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

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的数据库实现，须要同时往这两个数据库中插入相同的数据。下面分别对这两种需求进行解决。

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

针对这种状况有以下两种实现方式：

第二种实现方式

其实，在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()};
        }

而后运行起来看下效果吧

利用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的实现都获取到了！效果实现！

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

这时候咱们能够根据咱们预设的配置来动态获取咱们所须要的实现。这段话说的我本身都感受拗口。话很少少，开鲁吧！这里我将介绍三种实现方式。

根据咱们的配置文件中设置的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,到这里运行一下看下效果吧！而后改下配置文件再看下效果！

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

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

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

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

public string ImplementAssemblyName => "MultiImpDemo.A";

        public string Talk()
        {
            return "Talk from A.SayHello";
        }

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() };
        }

效果本身运行下看下吧！

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

首先修改下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大伙进行交流，最后感谢您的阅读！

posted @ 2019-01-07 22:50 依乐祝阅读( ...) 评论( ...) 编辑收藏