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

最近有个需求就是一个抽象仓储层接口方法需要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()};
        } 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");
 }

    然后运行起来看下效果吧

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

原文地址：https://www.cnblogs.com/yilezhu/p/10236163.html

时间： 2024-11-08 19:02:41

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

ASP.NET Core中使用自定义MVC过滤器属性的依赖注入

原文:ASP.NET Core中使用自定义MVC过滤器属性的依赖注入 除了将自己的中间件添加到ASP.NET MVC Core应用程序管道之外,您还可以使用自定义MVC过滤器属性来控制响应,并有选择地将它们应用于整个控制器或控制器操作. ASP.NET Core中常用的MVC过滤器之一是  ExceptionFilterAttribute,用于处理Wep API应用程序中的错误响应.它很容易实现,开发人员和我在ASP.NET Core中使用MVC过滤器属性所面临的问题是访问Startup.cs类

如何在ASP.NET Core中实现一个基础的身份认证

注:本文提到的代码示例下载地址> How to achieve a basic authorization in ASP.NET Core 如何在ASP.NET Core中实现一个基础的身份认证 ASP.NET终于可以跨平台了,但是不是我们常用的ASP.NET, 而是叫一个ASP.NET Core的新平台,他可以跨Windows, Linux, OS X等平台来部署你的web应用程序,你可以理解为,这个框架就是ASP.NET的下一个版本,相对于传统ASP.NET程序,它还是有一些不同的地方的,比

Python:多态（一个接口多种实现）

class Animal(object):----def init(self,name):--------self.name=name def talk(self): pass @staticmethod def animal_talk(obj): #动物叫的接口 obj.talk() class Cat(Animal):----def talk(self):--------print("mow!")class Dog(Animal):----def talk(self):------

IOC和AOP使用扩展 多种方式实现依赖注入

多种方式实现依赖注入 1.Spring 使用setter访问器实现对属性的赋值, 2.Spring 构造constructor方法赋值, 3.接口注入 4.Spring P命名空间注入直接量 setter访问器实现方式following 实体类中设置属性的set访问器 1 public class Equip { 2 private String name; //装备名称 3 public String getName() { 4 return name; 5 } 6 public void s

ASP.NET Core WebApi使用Swagger生成api说明文档看这篇就够了

引言 在使用asp.net core 进行api开发完成后,书写api说明文档对于程序员来说想必是件很痛苦的事情吧,但文档又必须写,而且文档的格式如果没有具体要求的话,最终完成的文档则完全取决于开发者的心情.或者详细点,或者简单点.那么有没有一种快速有效的方法来构建api说明文档呢?答案是肯定的, Swagger就是最受欢迎的REST APIs文档生成工具之一! 为什么使用Swagger作为REST APIs文档生成工具 Swagger 可以生成一个具有互动性的API控制台,开发者可以用来快速学

.NET Core实战项目之CMS 第二章 入门篇-快速入门ASP.NET Core看这篇就够了

作者:依乐祝 原文链接:https://www.cnblogs.com/yilezhu/p/9985451.html 本来这篇只是想简单介绍下ASP.NET Core MVC项目的(毕竟要照顾到很多新手朋友),但是转念一想不如来点猛的(考虑到急性子的朋友),让你通过本文的学习就能快速的入门ASP.NET Core.既然是快速入门所以过多过深的内容我这里就一笔带过了!然后在后面的一些列文章中再慢慢的对其中的概念进行阐述. 本文已收录至.NET Core实战项目之CMS 第一章 入门篇-开篇及总体规

使用Visual Studio Code开发.NET Core看这篇就够了

原文:使用Visual Studio Code开发.NET Core看这篇就够了 作者:依乐祝 原文地址:https://www.cnblogs.com/yilezhu/p/9926078.html 在本文中,我将带着大家一步一步的通过图文的形式来演示如何在Visual Studio Code中进行.NET Core程序的开发,测试以及调试.尽管Visual Studio Code的部分功能还达不到Visual Studio的水平,但它实际上已经足够强大来满足我们的日常开发.而且其轻量化,插件化

spring的@primary和@qualifier注解解决一个接口多个实现的注入问题

@Primary注解 Spring中有提供一个@Primary注解,具体的作用是在一个接口有多个实现类的情况下,会默认选择其中一种实现,帮助Spring对象的正常注入. 比如说现在有一个接口UserService,它有两个实现类UserServiceImpl1和UserServiceImpl2,根据依赖倒置的原则,在Spring中注入的对象应该是接口,由接口去调用具体的实现. // 接口 public interface UserService { String getUserName(); }

了解ASP.NET Core 依赖注入，看这篇就够了

DI在.NET Core里面被提到了一个非常重要的位置, 这篇文章主要再给大家普及一下关于依赖注入的概念,身边有工作六七年的同事还个东西搞不清楚.另外再介绍一下.NET  Core的DI实现以及对实例生命周期的管理(这个是经常面试会问到的问题).最后再给大家简单介绍一下在控制台以及Mvc下如何使用DI,以及如何把默认的Service Container 替换成Autofac. 一.什么是依赖注入 1.1 依赖 1.2 什么注入 为什么反转 何为容器 二..NET Core DI 2.1 实例的注