.NET Core 依赖注入 Microsoft.Extensions.DependencyInjection

已于 2023-12-11 18:33:42 修改
阅读量1.5k 收藏 14
点赞数 11
分类专栏： C# 文章标签： .netcore microsoft
于 2023-12-05 23:23:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44695769/article/details/134819501
版权

文章目录

前言

依赖注入是一个非常重要的编程思想，就和面向过程和面向对象一样，IOC和控制反转是一种解耦的编程思想。

什么是依赖注入

[C#]理解和入门依赖注入

为什么要用IOC:inversion of controll反转控制（把创建对象的权利交给框架）

C# 使用依赖注入

框架介绍

目前.NET 有两个最优的依赖注入框架

  • Microsoft.Extensions.DependencyInjection：微软官方依赖注入框架，听说在.net core 8.0得到了最强的性能提升
  • Autofac：听说也是最强的依赖注入框架，性能强，开销低，功能完善。

Dependency injection in ASP.NET Core

Autofac 官网

深入浅出依赖注入容器——Autofac

Microsoft.Extensions.DependencyInjection

目前打算用微软的IOC，毕竟是官方背书，性能有保证。

C# 依赖注入IServiceCollection的AddSingleton方法使用

Nuget安装

在这里插入图片描述

简单单例使用

声明个测试类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NETCore8.Models
{
    public class Person
    {
        public int Id { get; set; }

        public string ?Name { get; set; }

        public int Age { get; set; }


    }
}

主函数代码

using Microsoft.Extensions.DependencyInjection;
using NETCore8.Models;
using Newtonsoft.Json;
using System.ComponentModel.Design;

namespace NETCore8
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //构造依赖注入容器
            IServiceCollection services = new ServiceCollection();
            //注入Person单例，生命周期暂时不展开
            services.AddSingleton<Person>();
            var builder = services.BuildServiceProvider();

            //初始化单例
            var res = builder.GetService<Person>();
            res.Name = "小刘";
            res.Age = 15;
            Console.WriteLine(JsonConvert.SerializeObject(res));

            //从容器中拿到Person单例，确认是否已被赋值为小刘
            var res2 = builder.GetService<Person>();
            Console.WriteLine(JsonConvert.SerializeObject(res2));
            //修改单例，查看容器中的单例是否被修改
            res2.Name = "小红";
            res2.Age = 23;


            //再从容器中拿出单例
            var res3 = builder.GetService<Person>();
            Console.WriteLine(JsonConvert.SerializeObject(res3));
            

            Console.WriteLine("Hello, World!");
            Console.ReadKey();
        }
    }
}

打印结果

在这里插入图片描述
这个说明这个单例一旦被修改了，容器中的数据就会被修改。但是这样仅仅是和全局静态的效果一样。依赖注入没有这么简单

自动装配

自动装配的意思就是自动依赖注入。就是你不需要主动去声明构造函数，IOC容器会自动帮你去使用构造函数。

举例

这里为了简单说明，这里只使用单例自动装配举例。

namespace IOC_Test.Models
{
    public class Person
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public int Age {  get; set; }   
    }
}


namespace IOC_Test.Services
{
    public class PersonService
    {
        public Person Person { get; set; }
        /// <summary>
        /// 无参构造函数
        /// </summary>
        public PersonService() {
            Person = new Person();
        }


        /// <summary>
        /// 有参构造函数，IOC是选择尽可能多的参数构造
        /// </summary>
        /// <param name="person"></param>
        public PersonService(Person person)
        {

            this.Person = person;
        }
    }
}

自动装配测试用例

using IOC_Test.Models;
using IOC_Test.Services;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;

namespace IOC_Test
{
    internal class Program
    {
        static void Main(string[] args)
        {
            IServiceCollection services = new ServiceCollection();
            //注入依赖
            services.AddSingleton<Person>();
            services.AddSingleton<PersonService>();
            //生成IOC容器
            var builder = services.BuildServiceProvider();

            //两次打印，第一次打印PersonService的Person
            {
                var res = builder.GetService<PersonService>();
                Console.WriteLine(JsonConvert.SerializeObject(res?.Person));
            }
            //修改Person,看看PersonService里面是不是会受影响
            {
                var res = builder.GetService<Person>();
                res.Name = "小王";
                res.Age = 10;
            }
            //再次打印，如果被修改，那么就说明是自动装配。如果没被修改，就说明没有将Person自动注入到PersonService
            {
                var res = builder.GetService<PersonService>();
                Console.WriteLine(JsonConvert.SerializeObject(res?.Person));
            }


            Console.WriteLine("Hello, World!");

            Console.ReadLine();
        }
    }
}

打印结果

在这里插入图片描述

自动装配执行顺序

测试用例

这里我们新建一个Dog

namespace IOC_Test.Models
{
    public class Dog
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public int Age { get; set; }
    }
}

Person

namespace IOC_Test.Models
{
    public class Person
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public int Age {  get; set; }   
    }
}

PersonService

namespace IOC_Test.Services
{
    public class PersonService
    {
        public Person Person { get; set; }

        public Dog Dog { get; set; }

        /// <summary>
        /// 无参构造函数
        /// </summary>
        public PersonService() {
            Person = new Person();
        }
    }
}

主函数

namespace IOC_Test
{
    internal class Program
    {
        static void Main(string[] args)
        {
            IServiceCollection services = new ServiceCollection();
            //注入依赖
            services.AddSingleton<Person>();
            services.AddSingleton<PersonService>();
            services.AddSingleton<Dog>();
            //生成IOC容器
            var builder = services.BuildServiceProvider();

            //两次打印，第一次打印PersonService
            {
                var res = builder.GetService<PersonService>();
                Console.WriteLine(JsonConvert.SerializeObject(res));
            }
            //修改Person和Dog,看看PersonService里面是不是会受影响
            {
                var person = builder.GetService<Person>();
                person.Name = "小王";
                person.Age = 10;
                var dog = builder.GetService<Dog>();
                dog.Name = "旺财";
                dog.Age = 2;
            }
            //再次打印，查看自动装配如何执行
            {
                var res = builder.GetService<PersonService>();
                Console.WriteLine(JsonConvert.SerializeObject(res));
            }


            Console.WriteLine("Hello, World!");

            Console.ReadLine();
        }
    }
}
有歧义构造函数
namespace IOC_Test.Services
{
    public class PersonService
    {
        public Person Person { get; set; }

        public Dog Dog { get; set; }

        /// <summary>
        /// 无参构造函数
        /// </summary>
        public PersonService() {
            Person = new Person();
        }

        public PersonService(Person person)
        {
            this.Person = person;
        }

        public PersonService(Dog dog) {
            this.Dog = dog;
        }
    }
}

如果构造函数出现歧义，比如这里既可以选择Person构造，又可以选择Dog构造，会报错
在这里插入图片描述

渐进式构造函数
namespace IOC_Test.Services
{
    public class PersonService
    {
        public Person Person { get; set; }

        public Dog Dog { get; set; }

        /// <summary>
        /// 无参构造函数
        /// </summary>
        public PersonService() {
            Person = new Person();
        }

        public PersonService(Person person)
        {
            this.Person = person;
        }

        public PersonService(Person person,Dog dog) {
            this.Person= person;
            this.Dog = dog;
        }
    }
}

运行成功
在这里插入图片描述

循环依赖

Person注入Dog，Dog注入Person，看看效果如何

namespace IOC_Test.Models
{
    public class Person
    {
        public Dog Dog { get; set; }

        public int Id { get; set; }

        public string Name { get; set; }

        public int Age { get; set; }
        public Person(Dog dog)
        {
            Dog = dog;
        }
    }
}

namespace IOC_Test.Models
{
    public class Dog
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public int Age { get; set; }

        public Person Person { get; set; }
        public Dog(Person person)
        {
            Person = person;
        }
    }
}

在这里插入图片描述

自动装配结论

自动装配是尽可能主动去装配服务，如果出现装配歧义，循环依赖，那么就会主动抛出异常。自动装配可以极大的减少对构造函数维护，我们不需要知道服务是怎么声明的，IOC容器会帮助我们自动声明相互之间的依赖。这张图就能很好的解释自动装配的效果

在这里插入图片描述

手动装配

自动装配是由IOC容器自动装配的类。如果需要装配多个同类的服务，那就要手动进行区别了。

手动注入

internal class Program
{
    static void Main(string[] args)
    {
        IServiceCollection services = new ServiceCollection();
        services.AddSingleton<Person>(sp =>
        {
            var res = new Person() {
                Name = "小红",
                Age = 19
            };
            return res;
        });
        //生成容器
        var builder = services.BuildServiceProvider();
        {
            var res = builder.GetService<Person>();
            Console.WriteLine(JsonConvert.SerializeObject(res));
        }
        

        Console.WriteLine("Hello, World!");

        Console.ReadLine();
    }
}

在这里插入图片描述

别名注入



namespace IOC_Test
{
    internal class Program
    {
        static void Main(string[] args)
        {
            IServiceCollection services = new ServiceCollection();
            services.AddKeyedSingleton<Person>("A",(sp,key) =>
            {
                var res = new Person() {
                    Name = "小红",
                    Age = 19
                };
                return res;
            });

            services.AddKeyedSingleton<Person>("B", (sp, key) =>
            {
                var res = new Person()
                {
                    Name = "小蓝",
                    Age = 23
                };
                return res;
            });
            //生成容器
            var builder = services.BuildServiceProvider();
            
            //获取服务，当Key找不到时自动返回Null
            {
                var res = builder.GetService<Person>();
                Console.WriteLine("获取默认服务");
                Console.WriteLine(JsonConvert.SerializeObject(res));
            }
            {
                var res = builder.GetKeyedService<Person>("A");
                Console.WriteLine("获取A,Person");
                Console.WriteLine(JsonConvert.SerializeObject(res));
            }
            {
                var res = builder.GetKeyedService<Person>("B");
                Console.WriteLine("获取B,Person");
                Console.WriteLine(JsonConvert.SerializeObject(res));
            }


            Console.WriteLine("Hello, World!");

            Console.ReadLine();
        }
    }
}

在这里插入图片描述

声明别名的服务将不会自动装配，即使声明的别名相同。建议使用多个不同名的服务来自动装配。手动声明别名需要手动装配对应关系

也可以在输入的时候主动拿到按照Key去寻找服务。

internal class Program
{
    static void Main(string[] args)
    {
        IServiceCollection services = new ServiceCollection();
		//依赖注入是使用的时候去构造，所以声明顺序不影响实际运行顺序，有点类似于回调函数
        services.AddKeyedSingleton<Person>("A",(sp,key) =>
        {
            //Console.WriteLine(key);
            var res = new Person() {
                Name = "小红",
                Age = 19
            };
            return res;
        });
        services.AddKeyedSingleton<PersonService>("A", (sp, key) =>
        {
            return new PersonService(sp.GetKeyedService<Person>(key));
        });

        //生成容器
        var builder = services.BuildServiceProvider();
   
        //获取服务
        {
            var res = builder.GetKeyedService<Person>("A");
            Console.WriteLine("获取默认服务");
            Console.WriteLine(JsonConvert.SerializeObject(res));
        }
        //获取服务
        {
            var res = builder.GetKeyedService<PersonService>("A");
            Console.WriteLine("获取默认服务");
            Console.WriteLine(JsonConvert.SerializeObject(res));
        }

        Console.WriteLine("Hello, World!");

        Console.ReadLine();
    }
}

依赖注入的构造顺序

依赖注入是使用的时候去生成，而不是注入的时候生成

namespace IOC_Test
{
    internal class Program
    {
        static void Main(string[] args)
        {
            IServiceCollection services = new ServiceCollection();

            services.AddKeyedSingleton<Person>("A",(sp,key) =>
            {
                Console.WriteLine($"构造函数执行,key[{key}]");
                var res = new Person() {
                    Name = "小红",
                    Age = 19
                };
                return res;
            });
            //生成容器
            var builder = services.BuildServiceProvider();
       
            //获取服务
            {
                Console.WriteLine("获取Key[A]服务");
                var res = builder.GetKeyedService<Person>("A");
                Console.WriteLine(JsonConvert.SerializeObject(res));
            }

            Console.WriteLine("Hello, World!");

            Console.ReadLine();
        }
    }
}

在这里插入图片描述

结尾

IOC容器还有许多别的功能，比如别名，接口注入，注解注入，声明周期等。这个我还不太了解。现在的单例自动装配已经基本满足了我的功能，我以后有时间会去深入了解。

龙中舞王
关注
  • 11
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
.Net利用Microsoft.Extensions.DependencyInjection配置依赖注入
qq_27860623的博客
03-01 875
为了让接口程序更加模块化和可测试，采用依赖注入的方式调用接口方法。
.NET：依赖注入
子昊
09-03 4684
控制反转（Inversion of Control，缩写为IOC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。用来注册服务、解析实例。 依赖注入（Dependency Injection，简称DI）是一个将行为从依赖中分离的技术，简单地说，它允许开发者定义一个方法函数依赖于外部其他各种交互，而不需要编码如何获得这些外部交互的实例。 为了方便理解，我使
WPF 依赖注入之 Microsoft.Extensions.DependencyInjection
四方阵
01-08 649
WPF 依赖注入之 Microsoft.Extensions.DependencyInjection
.Net依赖注入
qq_58159494的博客
03-14 1185
什么是依赖注入，依赖注入的简单实现，服务生存期，获取服务的方法，Web Api中使用依赖注入
DotNetCore跨平台~一起聊聊Microsoft.Extensions.DependencyInjection
weixin_34192816的博客
10-11 353
回到目录 写这篇文章的心情：激动 Microsoft.Extensions.DependencyInjection在github上同样是开源的，它在dotnetcore里被广泛的使用，比起之前的autofac,unity来说，它可以说是个包裹，或者叫适配器，它自己提供了默认的DI实现，同时也支持第三方的IOC容器，在这段时间里使用了它，就想，这东西为什么被在dotnetcore里大放异彩？为什...
.NET 依赖注入的三种方法
qq_40109267的博客
07-15 1401
1.
Microsoft.Extensions.DependencyInjection 之三：反射可以一战（附源代码）
代码小牛的博客
11-07 2256
目录 前文回顾IServiceCallSite CallSiteFactory ServiceProviderEngine CompiledServiceProviderEngine DynamicServiceProviderEngine 测试参数-m|...
Autofac.Extensions.DependencyInjection:Microsoft.Extensions.DependencyInjection.Abstractions（.NET Core依赖项注入抽象）中接口的Autofac实现
05-07
Autofac是Microsoft .NET的。 它管理类之间的依赖关系，以使应用程序随大小和复杂性的增长而保持易于更改的状态。 这是通过将常规.NET类视为。 请在此存储库中而不是在Autofac核心存储库中提交问题并请求对此...
NLog.Extensions.Logging:用于.NET标准库和.NET Core应用程序的Microsoft.Extensions.Logging的NLog提供程序
05-11
您可以选择在.NET Core控制台应用程序中使用NLog时是否使用依赖注入。 如果您不想使用DI，则可以将添加到项目中，手动添加NLog.config文件，按照本进行操作GetCurrentClassLogger() ，然后将其用于日志记录。 要...
AutoMapper.Extensions.Microsoft.DependencyInjection
05-14
Microsoft.Extensions.DependencyInjection的AutoMapper扩展 扫描程序集并： 将配置文件添加到映射配置向容器添加值解析器，成员值解析器，类型转换器。 要与IServiceCollection实例和一个或多个程序集一起使用，请...
Dazinator.Extensions.DependencyInjection:Microsoft.Extensions.DependencyInjection的有用添加，例如命名服务
05-10
此存储库建立在Microsoft.Extensions.DependencyInjection.Abstractions基础上，以提供其他功能，当前包括： 命名服务 儿童箱 它还提供了一个单独的（和可选的）nuget包，称为Dazinator.Extensions....
Microsoft.Extensions.DependencyInjection.Abstractions 8.0.1
最新发布
05-11
Microsoft.Extensions.DependencyInjection.Abstractions 8.0.1
Discord.Addons.Hosting:使用 .NET 通用主机 (Microsoft.Extensions.Hosting) 简化 Discord.Net 托管
05-30
// CreateDefaultBuilder configures a lot of stuff for us automatically// See: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/host/generic-hostvar hostBuilder = Host . CreateDefaultBuilder ...
.Net 3.5 使用 System.Threading.Task
02-10
.Net 3.5 下使用的 System.Threading.Tasks。...安装完成后，添加引用时只需要在安装目录 C:\Program Files (x86)\Microsoft Reactive Extensions\Redist\DesktopV2 下找到 System.Threading.dll，添加即可
PosInformatique.AspNet.WebForms.DependencyInjection：PosInformatique.AspNet.WebForms.DependencyInjection是一个库，用于为Microsoft .Extensions.DependencyInjection添加ASP.NET Web窗体的IoC容器支持。
01-30
PosInformatique.AspNet.WebForms.DependencyInjection是一个库，用于添加Microsoft.Extensions.DependencyInjection对ASP.NET Web窗体的IoC容器支持 从NuGet安装 可直接在官方网站上获得。 使用以下NuGet命令行将...
StructureMap.Microsoft.DependencyInjection, StructureMap支持 Microsoft.Extensions.DependencyInjection.zip
09-18
StructureMap.Microsoft.DependencyInjection, StructureMap支持 Microsoft.Extensions.DependencyInjection 用于 ASP.NET 核心的 StructureMap集成 这里存储库包含两个NuGet软件包的来源：StructureMap....
【Unity Code】Unity C# 使用微软 DependencyInjection 库实现依赖注入实验
qq_49309833的博客
11-16 279
验证了Microsoft.Extensions.DependencyInjection库在unity中使用的可行性练习了DependencyInjection库的基本使用为游戏框架开发提供支撑。
使用微软依赖注入器Microsoft.Extensions.DependencyInjection
u011511086的专栏
01-15 4816
注册服务到容器 using Microsoft.Extensions.DependencyInjection; using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using System.Text; using System.Threading.Tasks; using WebNetCore5_Img_Storage.BLL; using WebNetCore5_Img_St
.NET CORE依赖注入
Abel_01_xu的博客
03-21 1875
依赖注入框架利用 ServiceLifetime 来表示 Singleton、Scoped和Transient这3种生命周期模式Transient代表容器针对每次服务请求都会创建一个新的服务实例；Self将提供服务实例保存在当前容器中，它代表针对某个容器范围内的单例模式；Root将每个容器提供的服务实例统一存放到根容器中，所以该模式能够在多个“同根”容器范围内确保提供的服务是单例的。// 将每个容器提供的服务实例统一存放到根容器中，
WPF 使用Microsoft.Extensions.DependencyInjection
05-28
WPF (Windows Presentation Foundation) 是一个基于 .NET Framework 的 UI 框架，它提供了丰富的界面设计和开发功能。在 WPF 中使用 Microsoft.Extensions.DependencyInjection 可以帮助我们更好地实现依赖注入(Dependency Injection)。 Microsoft.Extensions.DependencyInjection 是 .NET Core 中的一个轻量级依赖注入框架，它提供了简单、灵活的依赖注入方式。在 WPF 中，我们同样可以使用该框架来实现依赖注入。 首先，我们需要在 WPF 应用程序中安装 Microsoft.Extensions.DependencyInjection NuGet 包。 在 App.xaml.cs 文件中，我们可以创建一个 IServiceCollection 对象，并在其中注册依赖： ```csharp public partial class App : Application { public static IServiceProvider ServiceProvider { get; private set; } protected override void OnStartup(StartupEventArgs e) { base.OnStartup(e); var services = new ServiceCollection(); // 注册依赖 services.AddSingleton<IMyService, MyService>(); // 创建容器 ServiceProvider = services.BuildServiceProvider(); } } ``` 在上面的代码中，我们注册了一个名为 `MyService` 的服务，并指定其实现接口为 `IMyService`。当我们需要使用该服务的时候，可以通过 ServiceProvider 来解析： ```csharp var service = App.ServiceProvider.GetService<IMyService>(); ``` 这样就完成了依赖注入的过程。在 WPF 中，我们通常会在 ViewModel 中使用依赖注入，来实现视图和逻辑的分离。通过使用 Microsoft.Extensions.DependencyInjection，我们可以更方便地管理和注入依赖项，提高代码的可测试性和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值