ASP.NET Core  依赖注入框架的使用

目录
  • 一、IoC框架
  • 二、IoC-Autofac
  • 三、.NET Core中自带DI的使用
  • 四、Autofac 使用
  • 五、批量注入

前言:

还记得上篇文章中ASP.NET Core 依赖注入详细最后提及到,假如服务越来越多怎么处理呢,本篇文章将会带来解决办法。这篇是接上一篇文章的,概念方面的可以参考上一篇文章。

一、IoC框架

先说说常见的Ioc框架吧。
Autofac: 目前net用的比较多,好多大佬的项目比较优先选择的框架。
Ninject: 已经很少用了,还时在很早的文章中见过。
Unity: 比较常见的了,好多地方有用到的,
Core: Core中自带的,业务逻辑不太复杂的情况下,还是比较方便的。

二、IoC-Autofac

Autofac.NET领域最为流行的IOC框架之一,传说是速度最快的一个。

优点:

  • 它是C#语言联系很紧密,也就是说C#里的很多编程方式都可以为Autofac使用。
  • 较低的学习曲线,学习它非常的简单,只要你理解了IoC和DI的概念以及在何时需要使用它们。
  • XML.Json配置支持。
  • 自动装配。
  • Asp.Net MVC 集成。
  • 微软的Orchad开源程序使用的就是Autofac,从该源码可以看出它的方便和强大。

大多数讲Autofac框架的文章中都会提及上面几点优点,可见其框架的优秀。

三、.NET Core中自带DI的使用

1.首先创建一个 ASP.Net Core Web Api项目(选用的.NET 5.0),整体如下,红色部分为Core中自带DI使用的部分。

2.新建类库项目,分别添加一个接口文件和类文件。

接口:

    public interface ISayHelloService
    {
        string SayHello(string name);
    }

类:

    public class EnglishSayHelloService : ISayHelloService
    {
        public string SayHello(string name)
        {
            return $"Hello,{name}!";
        }
    }

3.在 Startup 里面的 ConfigureServices 方法内注入。

 services.AddScoped<ISayHelloService, EnglishSayHelloService>();

4.然后在控制器中使用刚刚注入的服务。

    [Route("api/[controller]/[action]")]
    [ApiController]
    public class HelloController : ControllerBase
    {
        public readonly ISayHelloService sayHelloService;

        public HelloController(ISayHelloService sayHelloService)
        {
            this.sayHelloService = sayHelloService;
        }

        [HttpGet]
        public string CoreDI()
        {
            return  sayHelloService.SayHello("CoreDI");
        }

    }

注意: 路由访问地址,出现404错误时,可能是路由问题,路由可根据自己的实际需要自己在[Route("api/[controller]/[action]")]处修改。

5.访问测试。

这里使用的接口测试软件是Postman,Api测试很方便,网上可以搜索到,找不到我到的可以联系我。

四、Autofac 使用

1.在新建一个ASP.Net Core Web Api项目(选用的.NET 5.0)用于区分前面的Core自带的DI。

2.引用引用 Autofac 的包,看看这下载量,还是很哇塞的

3.在 Program 中改用 Autofac 来实现依赖注入

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });
    }

4.在 Startup 类中添加方法:ConfigureContainer,注入我们之前的服务。

   public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
        }
        //在这里注入
        public void ConfigureContainer(ContainerBuilder builder)
        {
            builder.RegisterType<EnglishSayHelloService>().As<ISayHelloService>();

        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }

    }

5.控制器这里基本不需要更改。

   [Route("api/[controller]/[action]")]
    [ApiController]
    public class HelloController : ControllerBase
    {
        public readonly ISayHelloService sayHelloService;

        public HelloController(ISayHelloService sayHelloService)
        {
            this.sayHelloService = sayHelloService;
        }

        [HttpGet]
        public string CoreDI()
        {
            return  sayHelloService.SayHello("AutofacDI");
        }

    }

6.运行项目继续用Postman测试接口。

好了关于Autofac的基本使用基本就讲完了,是不是还是挺简单的。

五、批量注入

简单的几个服务写着还可以接受,当服务到几十个,甚至上百个时,想想就可怕。这就不得不说到批量注入了,Autofac的优势就体现出来了。

1.在服务中分别在添加一个接口,和类。

接口:

   public interface IUseAutofacService
   {
       string UseAutofac(string name);
   }

类:

   public class UseAutofacService : IUseAutofacService
   {
       public string UseAutofac(string name)
       {
           return $"{name}批量注入测试!";
       }
   }

2.回到我们之前的Startup 类中修改方法:ConfigureContainer

       public void ConfigureContainer(ContainerBuilder builder)
       {
           //builder.RegisterType<EnglishSayHelloService>().As<ISayHelloService>();

           //服务项目程序集
           Assembly service = Assembly.Load("Autofac.Service");

           //服务接口项目程序集
           Assembly iservice = Assembly.Load("Autofac.Service");

           builder.RegisterAssemblyTypes(service, iservice).Where(n => n.FullName.EndsWith("Service") && !n.IsAbstract)
               .InstancePerLifetimeScope().AsImplementedInterfaces();

       }

注意: 如果需要注入的服务没有 IXXXService的接口 ,那么 builder.RegisterAssemblyTypes 就只需要传一个程序集。如果服务与接口同在一个项目,那也是要传两个程序集的。

3.接下来在刚刚的控制器中略作修改。

   [Route("api/[controller]/[action]")]
    [ApiController]
    public class HelloController : ControllerBase
    {
        public readonly ISayHelloService sayHelloService;

        public readonly IUseAutofacService useAutofacService;

        public HelloController(ISayHelloService _sayHelloService, IUseAutofacService _useAutofacService)
        {
            this.sayHelloService = _sayHelloService;
            this.useAutofacService = _useAutofacService;
        }

        [HttpGet]
        public string AutofacDI()
        {
            return sayHelloService.SayHello("AutofacDI");
        }

        public string BathAutofacDI()
        {
            var name = sayHelloService.SayHello("AutofacDI");
            return useAutofacService.UseAutofac(name);
        }
    }

4.用Postman测试注入的情况。

到此这篇关于 ASP.NET Core  依赖注入框架的使用的文章就介绍到这了,更多相关 ASP.NET Core  依赖注入框架内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 详解ASP.NET Core 中的框架级依赖注入

    1.ASP.NET Core 中的依赖注入 此示例展示了框架级依赖注入如何在 ASP.NET Core 中工作. 其简单但功能强大,足以完成大部分的依赖注入工作.框架级依赖注入支持以下 scope: Singleton - 总是返回相同的实例 Transient - 每次都返回新的实例 Scoped - 在当前(request)范围内返回相同的实例 假设我们有两个要通过依赖注入来进行工作的工件: PageContext - 自定义请求上下文 Settings - 全局应用程序设置 这两个都是非常

  • ASP.NET Core  依赖注入框架的使用

    目录 一.IoC框架 二.IoC-Autofac 三..NET Core中自带DI的使用 四.Autofac 使用 五.批量注入 前言: 还记得上篇文章中ASP.NET Core 依赖注入详细最后提及到,假如服务越来越多怎么处理呢,本篇文章将会带来解决办法.这篇是接上一篇文章的,概念方面的可以参考上一篇文章. 一.IoC框架 先说说常见的Ioc框架吧. Autofac: 目前net用的比较多,好多大佬的项目比较优先选择的框架. Ninject: 已经很少用了,还时在很早的文章中见过. Unity

  • 详解asp.net core 依赖注入

    前言 好久没有写微博了,因为前段时间由于家庭原因决定从工作了3年多的北京转移到上海去.依赖注入在学习net core的时候也有写过类似的东西,只是实践的较少,结果来到上海新公司系统框架涉及到了这块知识点,所以在了解完自己的项目之后决定做一些相关的总结.接下来就让我们先来了解hewi依赖注入. 什么是依赖注入 依赖注入,全称是"依赖注入到容器", 容器(IOC容器)是一个设计模式,它也是个对象,你把某个类(不管有多少依赖关系)放入这个容器中,可以"解析"出这个类的实例

  • 理解ASP.NET Core 依赖注入(Dependency Injection)

    目录 依赖注入 什么是依赖注入 依赖注入有什么好处 ASP.NET Core内置的依赖注入 服务生存周期 服务释放 TryAdd{Lifetime}扩展方法 解析同一服务的多个不同实现 Replace && Remove 扩展方法 Autofac 服务解析和注入 构造函数注入 方法注入 属性注入 一些注意事项 框架默认提供的服务 依赖注入 什么是依赖注入 简单说,就是将对象的创建和销毁工作交给DI容器来进行,调用方只需要接收注入的对象实例即可. 微软官方文档-DI 依赖注入有什么好处 依赖

  • ASP.NET Core 依赖注入详细

    目录 一.控制反转 二.好莱坞法则 三.流程控制 四.三种依赖注入方式 1.构造器注入 2.属性注入 3.方法注入 五.生命周期 六.ASP.Net Core 中自带的注入 前言: ASP.NET Core 应用在启动过程中会依赖各种组件提供服务,而这些组件会以接口的形式标准化,这些组件这就是我们所说的服务,ASP.NET Core框架建立在一个底层的依赖注入框架之上,它使用容器提供所需的服务.要了解依赖注入容器以及它的机制,我们需要了解什么是依赖注入. 一.控制反转 说道依赖注入就不得不提控制

  • ASP.NET Core依赖注入详解

    目录 一.什么是依赖注入 二.使用框架提供的服务 三.注册服务 四.生命周期 五.请求服务 六.设计你的依赖服务 ASP.NET Core的底层设计支持和使用依赖注入.ASP.NET Core应用程序可以利用内置的框架服务将它们注入到启动类的方法中,并且应用程序服务能够配置注入.由ASP.NET Core提供的默认服务容器提供了最小功能集,并不是要取代其它容器. 一.什么是依赖注入 依赖注入(Dependency injection,DI)是一种实现对象及其合作者或依赖项之间松散耦合的技术.将类

  • ASP.NET Core依赖注入(DI)讲解

    ASP.NET Core的底层设计支持和使用依赖注入.ASP.NET Core 应用程序可以利用内置的框架服务将服务注入到启动类的方法中,并且应用程序服务也可以配置注入.由ASP.NET Core 提供的默认服务容器提供了最小功能集,并不是取代其他容器. 1.浅谈依赖注入 依赖注入(Dependency injection,DI)是一种实现对象和依赖者之间松耦合的技术,将类用来执行其操作的这些对象以注入的方式提供给该类,而不是直接实例化依赖项或者使用静态引用.一般情况,类会通过构造函数声明器2依

  • ASP.NET Core依赖注入系列教程之服务的注册与提供

    前言 在采用了依赖注入的应用中,我们总是直接利用DI容器直接获取所需的服务实例,换句话说,DI容器起到了一个服务提供者的角色,它能够根据我们提供的服务描述信息提供一个可用的服务对象.ASP.NET Core中的DI容器体现为一个实现了IServiceProvider接口的对象. ServiceProvider与ServiceDescriptor 服务的注册与提供     利用ServiceProvider来提供服务     提供一个服务实例的集合     获取ServiceProvider自身对

  • ASP.NET Core依赖注入系列教程之控制反转(IoC)

    前言 ASP.NET Core在启动以及后续针对每个请求的处理过程中的各个环节都需要相应的组件提供相应的服务,为了方便对这些组件进行定制,ASP.NET通过定义接口的方式对它们进行了"标准化",我们将这些标准化的组件称为服务,ASP.NET在内部专门维护了一个DI容器来提供所需的服务.要了解这个DI容器以及现实其中的服务提供机制,我们先得知道什么是DI(Dependence Injection),而一旦我们提到DI,又不得不说IoC(Inverse of Control). 一.流程控

  • Asp.net core程序中使用微软的依赖注入框架

    我之前在博文中介绍过Asp.net core下系统自带的依赖注入框架,这个依赖框架在Microsoft.Extensions.DependencyInjection中实现,本身并不是.net core的一部分(是asp.net core的一部分),本文这里就简单的介绍下载.net core控制台程序中使用这个框架,顺便也了解下这个框架的全貌. 首先我们需要安装Microsoft.Extensions.DependencyInjection这个Nuget包,也可以直接使用Microsoft.Asp

  • ASP.NET Core依赖关系注入

    1.前言 面向对象设计(OOD)里有一个重要的思想就是依赖倒置原则(DIP),并由该原则牵引出依赖注入(DI).控制反转(IOC)及其容器等老生常谈的概念,初学者很容易被这些概念搞晕(包括我在内),在学习Core依赖注入服务之前,下面让我们先了解下依赖倒置原则(DIP).依赖注入(DI).控制反转(IOC)等概念,然后再深入学习Core依赖注入服务. 2.依赖倒置原则(DIP) 高层模块不依赖于低层模块的实现,而低层模块依赖于高层模块定义的接口.通俗来讲,就是高层模块定义接口,低层模块负责实现.

随机推荐