netcore使用依赖注入

最新推荐文章于 2025-03-31 01:00:00 发布

原创最新推荐文章于 2025-03-31 01:00:00 发布 · 919 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

本文详细介绍了在NetCore2与NetCore3环境下使用Autofac进行依赖注入的两种常见方法，包括构造函数注入及初始化注入，并对比了不同版本间的实现差异。

netcore2下大多推荐使用autofac使用，常用两种方式

1.构造函数的方式：有startup代码侵入，在构造函数参数中声明使用

需要修改了ConfigureServices的返回类型

public IServiceProvider ConfigureServices(IServiceCollection services)
{
       services.AddControllersWithViews().AddRazorRuntimeCompilation();
       return RegisterAutofac(services);//注册Autofac
}

private IServiceProvider RegisterAutofac(IServiceCollection services)
{
            //实例化Autofac容器
            var builder = new ContainerBuilder();
            //将Services中的服务填充到Autofac中
            builder.Populate(services);
            //新模块组件注册    
            builder.RegisterModule<AutofacModuleRegister>();
            //创建容器
            var Container = builder.Build();

            //第三方IOC接管 core内置DI容器 ，构造函数参数方式
            return new AutofacServiceProvider(Container);
}

2.初始化的方式：代码量会多，但在使用时比较自由

通过 IOCContainerManager.Resolve<IUserRepository>();来动态使用，不限于构造函数中，类似于new，但无须关注实现类

public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews().AddRazorRuntimeCompilation();
            RegisterAutofac(services);//注册Autofac
        }

        private void RegisterAutofac(IServiceCollection services)
        {
            //实例化Autofac容器
            var builder = new ContainerBuilder();
            //将Services中的服务填充到Autofac中
            builder.Populate(services);
            //新模块组件注册    
            builder.RegisterModule<AutofacModuleRegister>();
            //创建容器
            var Container = builder.Build();

           IOCContainerManager.Initialize(Container);
        }

netcore3下使用autofac,与netcore2不一样

首先在program.cs中需要增加服务

  public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                })
                .UseServiceProviderFactory(new AutofacServiceProviderFactory()); //增加的行
    }

再在startup.cs中，更加简单，使用预留的函数：ConfigureContainer，之前自己写的方法RegisterAutofac不再需要。

在构造函数的声明参数使用。

 public void ConfigureContainer(ContainerBuilder builder) //3.netcore3.0以后的方式
        {
            //添加依赖注入关系
            builder.RegisterModule(new AutofacModuleRegister());
            var controllerBaseType = typeof(ControllerBase);
            //在控制器中使用依赖注入
            builder.RegisterAssemblyTypes(typeof(Program).Assembly)
                .Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType)
                .PropertiesAutowired();
        }

使用微软自带的DI也能使用，只是要使用for循环注册

       /// <summary>
        ///
        /// </summary>
        /// <param name="service">IServiceCollection</param>
        /// <param name="assemblyName">程序集的名称</param>
        /// <param name="injection">生命周期</param>
        public static void RegisterAssembly(IServiceCollection services, string assemblyName, ServiceLifetime injection = ServiceLifetime.Scoped)
        {
            CheckNull.ArgumentIsNullException(services, nameof(services));
            CheckNull.ArgumentIsNullException(assemblyName, nameof(assemblyName));
            var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(assemblyName));
            if (assembly.IsNullT())
            {
                throw new DllNotFoundException($"\"{assemblyName}\".dll不存在");
            }
            var types = assembly.GetTypes().Where(o =>
            (typeof(IDependency).IsAssignableFrom(o)) && !o.IsInterface).ToList();
            //&& !o.Name.Contains("Base")
            foreach (var type in types)
            {
                var faces = type.GetInterfaces().Where(o => o.Name != "IDependency" && !o.Name.Contains("Base")).ToArray();
                if (faces.Any())
                {
                    var interfaceType = faces.FirstOrDefault();
                    switch (injection)
                    {
                        case ServiceLifetime.Scoped:
                            services.AddScoped(interfaceType, type);
                            break;

                        case ServiceLifetime.Singleton:
                            services.AddSingleton(interfaceType, type);
                            break;

                        case ServiceLifetime.Transient:
                            services.AddTransient(interfaceType, type);
                            break;
                    }
                }
            }
        }