百度360必应搜狗淘宝本站头条
mqtt服务器xftp6mybatiscollectionkeyerrorc#var
当前位置：网站首页 > 热门文章 > 正文

仿ABP实现模块注入方法（adp模块）

bigegpt 2024-08-02 10:45 9 浏览

ABP的模块注入非常不错，但是ABP太臃肿了，单独的模块或者功能不能抽出来单独使用，所以就想自己实现一个模块注入方法。

ABP的模块注入原理，是程序启动时扫描所有dll模块，进行批量注入，下面是实现方法。

一、模块抽象类

查看代码

二、每个子项目下添加DependencyModule类

查看代码

namespace Core
{
    public class DependencyModule : ICoreModule
    {
        public override void Register()
        {
            //可以根据启动项目/项目环境来判断注入，例如单元测试项目
            if (this.CurrentDomainName == "UnitTest" || this.IsDevelopment)
            {
                AutofacFactory.RegisterAssemblyTypes(Assembly.GetExecutingAssembly());
                AutofacFactory.RegisterTypeAs(typeof(IAuthContext), typeof(AuthContext));
            }
            else 
            {
                AutofacFactory.RegisterAssemblyTypes(typeof(BaseRepository<>).Assembly,
                    x => x.IsClass && !x.IsInterface,
                    x => x.BaseType.IsGenericType && x.BaseType.GetGenericTypeDefinition() == typeof(BaseRepository<>));

                AutofacFactory.RegisterAssemblyTypes(typeof(BaseEs<>).Assembly,
                    x => x.IsClass && !x.IsInterface,
                    x => x.BaseType.IsGenericType && x.BaseType.GetGenericTypeDefinition() == typeof(BaseEs<>));
            }
        }
    }
}

查看代码


namespace ServerApi
{
    public class DependencyModule : ICoreModule
    {
        public override void Register()
        {
            AutofacFactory.RegisterAssemblyTypes(typeof(Startup).Assembly,
                             x => x.IsClass && !x.IsInterface,
                             x => x.BaseType.IsGenericType && x.BaseType.GetGenericTypeDefinition() == typeof(IHandler<>));
        }
    }
}

三、项目启动时，注入autofac容器

1、.netcore2.1

关键代码 return new AutofacServiceProvider(AutofacExt.InitAutofac(services));

查看代码


namespace WebApi
{
    public class Startup
    {
        public Startup(IConfiguration configuration, IOptions<AppSetting> appConfiguration)
        {
            Configuration = configuration;
            _appConfiguration = appConfiguration;
        }

        public IConfiguration Configuration { get; }
        public IOptions<AppSetting> _appConfiguration;
        
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            services.Configure<AppSetting>(Configuration.GetSection("AppSetting"));
            services.AddMvc(config =>
            {
                config.Filters.Add<BasicFrameFilter>();
            })
            .AddControllersAsServices()
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
            services.AddMemoryCache();
            services.AddCors();
            var dbType = ((ConfigurationSection)Configuration.GetSection("AppSetting:DbType")).Value;
            if (dbType == Define.DBTYPE_SQLSERVER)
            {
                services.AddDbContext<BasicFrameDBContext>(options =>
                    options.UseSqlServer(Configuration.GetConnectionString("DBContext")));
            }
            else  //mysql
            {
                services.AddDbContext<BasicFrameDBContext>(options =>
                    options.UseMySql(Configuration.GetConnectionString("DBContext")));
            }
            services.AddHttpClient();

            return new AutofacServiceProvider(AutofacExt.InitAutofac(services));
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            app.UseAuthentication();
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Error");
            }

            app.UseStaticFiles();
            app.UseCookiePolicy();

            app.UseMvc(route =>
            {
                route.MapRoute(
                name: "default",
                template: "{controller=Home}/{action=Index}/{id?}");

                route.MapRoute(
                name: "areas",
                template: "{area:exists}/{controller=Home}/{action=Index}/{id?}");
            });

        }
    }
}

2、.netcore3.1

关键代码

.UseServiceProviderFactory(new AutofacServiceProviderFactory());

AutofacFactory.InitAutofac(builder);
builder.RegisterBuildCallback(scope =>
{
AutofacFactory.SetContainer((IContainer)scope);
});

查看代码


    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>();
                })
               .UseServiceProviderFactory(new AutofacServiceProviderFactory());
    }

查看代码


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

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews().AddControllersAsServices();

            services.AddControllers()
                    .AddNewtonsoftJson(options =>
                    {
                        options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();//修改属性名称的序列化方式，首字母小写
                        options.SerializerSettings.Converters.Add(new DateTimeConverter());//修改时间的序列化方式
                        options.SerializerSettings.Converters.Add(new LongConverter());
                    });

            services.AddOptions();
            services.AddMemoryCache();
            services.AddCors(options => options.AddPolicy("cors", builder => { builder.AllowAnyMethod().SetIsOriginAllowed(_ => true).AllowAnyHeader().AllowCredentials(); }));
            services.AddSignalR();
        }

        //Autofac注册
        public void ConfigureContainer(ContainerBuilder builder)
        {
            AutofacFactory.InitAutofac(builder);
            builder.RegisterBuildCallback(scope =>
            {
                AutofacFactory.SetContainer((IContainer)scope);
            });
        }

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

            app.UseCors("cors");
            app.UseWebSockets();
            //错误拦截中间件
            app.UseMiddleware<ExceptionMiddleware>();

            app.UseHttpsRedirection();
            app.UseStaticFiles();            
            app.UseRouting();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();     
                endpoints.MapHub<MessageHub>("/MessageHub");
                endpoints.Map("/", context =>
                {
                    context.Response.Redirect(#34;/api/Home/Index");
                    return Task.CompletedTask;
                });
            });
        }
    }

四、AutofacFactory类

查看代码


    public static class AutofacFactory
    {
        private static IContainer _container;
        private static ContainerBuilder _builder;

        static AutofacFactory()
        {
        }

        public static IContainer InitAutofac(IServiceCollection services)
        {
            _builder = new ContainerBuilder();

            RegisterAllModule();

            if (services.All(u => u.ServiceType != typeof(IHttpContextAccessor)))
            {
                services.AddScoped(typeof(IHttpContextAccessor), typeof(HttpContextAccessor));
            }

            _builder.Populate(services);
            _container = _builder.Build();
            return _container;
        }

        public static IContainer InitAutofac()
        {
            _container = _builder.Build();
            return _container;
        }

        public static void InitAutofac(ContainerBuilder builder)
        {
            _builder = builder;
            RegisterAllModule();
        }

        public static void SetContainer(IContainer container)
        {
            _container = container;
        }

        public static IContainer GetContainer()
        {
            return _container;
        }

        public static ContainerBuilder GetBuilder()
        {
            return _builder;
        }

        public static void RegisterAssemblyTypes(params Assembly[] assemblies)
        {
            _builder.RegisterAssemblyTypes(assemblies);
        }

        public static void RegisterAssemblyTypes(Assembly assemblie, params Func<Type, bool>[] predicates)
        {
            var regBuilder = _builder.RegisterAssemblyTypes(assemblie);
            foreach (var pre in predicates)
            {
                regBuilder.Where(pre);
            }
        }

        public static void RegisterTypeAs(Type iServiceType, Type implementationType, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterType(implementationType).As(iServiceType);
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        public static void RegisterType(Type serviceType, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterType(serviceType);
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        /// <summary>
        /// 泛型类型注册
        /// </summary>
        public static void RegisterGeneric(Type iServiceType, Type implementationType, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterGeneric(implementationType).As(iServiceType);
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        public static void RegisterGeneric(Type serviceType, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterGeneric(serviceType);
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        public static void RegisterType<iserviceType, implementationType>(AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterType<implementationType>().As<iserviceType>();
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        public static void Register<serviceType>(object obj, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.Register(x => obj).As<serviceType>();
            if (lifetime == AutofacLifetime.SingleInstance)
                regbuilder.SingleInstance();
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
                regbuilder.InstancePerLifetimeScope();
        }

        public static T Resolve<T>()
        {
            return _container.Resolve<T>();
        }

        public static object Resolve(Type type)
        {
            return _container.Resolve(type);
        }

        /// <summary>
        /// 注册全部模块
        /// </summary>
        public static void RegisterAllModule(params string[] dllnames)
        {
            var assembles = DependencyContext.Default.RuntimeLibraries.Select(x => x);
            if (dllnames.Count() > 0)
            {
                foreach (string dllname in dllnames)
                {
                    assembles = assembles.Where(o => o.Name.StartsWith(dllname));
                }
                var dlls = assembles.Select(o => Assembly.Load(new AssemblyName(o.Name))).ToArray();
            }
            else
            {
                var dlls = assembles.Where(o => o.Type == "project")
                                    .Select(o => Assembly.Load(new AssemblyName(o.Name))).ToArray();
            }

            //根据抽象类查找
            var types = AppDomain.CurrentDomain.GetAssemblies()
                        .SelectMany(a => a.GetTypes().Where(t => t.BaseType == typeof(ICoreModule) && t.BaseType.IsAbstract))
                        .ToArray();

            //根据接口查找
            //var types = AppDomain.CurrentDomain.GetAssemblies()
            //            .SelectMany(a => a.GetTypes().Where(t => t.GetInterfaces().Contains(typeof(ICoreModule))))
            //            .ToArray();

            foreach (var t in types)
            {
                var instance = (ICoreModule)Activator.CreateInstance(t);
                instance.Register();
            }
        }
    }

    /// <summary>
    /// 生命周期
    /// </summary>
    public enum AutofacLifetime
    {
        /// <summary>
        /// 默认生命周期,每次请求都创建新的对象
        /// </summary>
        InstancePerDependency,
        /// <summary>
        /// 每次都用同一个对象
        /// </summary>
        SingleInstance,
        /// <summary>
        /// 同一个Lifetime生成的对象是同一个实例
        /// </summary>
        InstancePerLifetimeScope
    }

相关推荐

或者这些Joplin插件也可以帮助你的笔记应用再一次强大

写在前面距离上次分享《搭建私有全平台多端同步笔记，群晖NAS自建JoplinServer服务》已过去一段时间，大家是否开始使用起来了呢？如果你和我一样已经使用过Joplin有一段时间了，那或许你也会...

Three.JS教程4 threejs中的辅助类

一、辅助类简介Three.js提供了一些辅助类（Helpers）以帮助我们更容易地调试、可视化场景中的元素。ArrowHelepr：创建箭头辅助器；AxisHelper：创建坐标轴辅助器；BoxH...

第2章 还记得点、线、面吗(二)（第二章还能敲钟吗）

glbgltf模型(webvrmodel)-gltf模型下载定制,glb模型下载定制,三维项目电商网站在线三维展示,usdz格式,vr模型网,网页VR模型下载,三维模型下载,webgl网页模型下载我...

如何检查Linux系统硬件信息?从CPU到显卡，一网打尽!

你可能会问：“我为什么要关心硬件信息？”答案很简单：硬件是Linux系统的根基，了解它可以帮你解决很多实际问题。比如：性能调优：知道CPU核心数和内存大小，才能更好地调整程序运行参数。故障排查：系统卡...

SpriteJS:图形库造轮子的那些事儿

从2017年到2020年，我花了大约4年的时间，从零到一，实现了一个可切换WebGL和Canvas2D渲染的，跨平台支持浏览器、SSR、小程序，基于DOM结构和支持响应式的，高...

平时积累的FPGA知识点(6)（fpga经典应用100例）

平时在FPGA群聊等积累的FPGA知识点，第六期：1万兆网接口，发三十万包，会出现掉几包的情况，为什么？原因：没做时钟约束，万兆网接口的实现，本质上都是高速serdes，用IP的话，IP会自带约束。...

芯片逻辑调度框架设计 都需要那些那些软件工具

设计芯片逻辑调度框架通常需要使用以下软件工具：1.逻辑设计工具：例如Vivado、Quartus、SynopsysDesignCompiler等，用于设计和实现逻辑电路。2.仿真工具：例如Mo...

ZYNQ与DSP之间EMIF16通信（正点原子领航者zynq之fpga开发指南v3）

本文主要介绍说明XQ6657Z35-EVM高速数据处理评估板ZYNQ与DSP之间EMIF16通信的功能、使用步骤以及各个例程的运行效果。[基于TIKeyStone架构C6000系列TMS320C6...

好课推荐:从零开始大战FPGA（从零开始的冒险4399）

从零开始大战FPGA引子：本课程为“从零开始大战FPGA”系列课程的基础篇。课程通俗易懂、逻辑性强、示例丰富，课程中尤其强调在设计过程中对“时序”和“逻辑”的把控，以及硬件描述语言与硬件电路相对应的“...

业界第一个真正意义上开源100 Gbps NIC Corundum介绍

来源：内容由「网络交换FPGA」编译自「FCCM2020」，谢谢。FCCM2020在5月4日开始线上举行，对外免费。我们有幸聆听了其中一个有关100G开源NIC的介绍，我们对该文章进行了翻译，并对其中...

高层次综合:解锁FPGA广阔应用的最后一块拼图

我们为什么需要高层次综合高层次综合（High-levelSynthesis）简称HLS，指的是将高层次语言描述的逻辑结构，自动转换成低抽象级语言描述的电路模型的过程。所谓的高层次语言，包括C、C++...

Xilinx文档编号及其内容索引(部分)

Xilinx文档的数量非常多。即使全职从事FPGA相关工作，没有几年时间不可能对器件特性、应用、注意事项等等有较为全面的了解。本文记录了我自使用Xilinx系列FPGA以来或精读、或翻阅、或查询过的文...

Xilinx Vivado联合Modelsim软件仿真

引言：Xilinx公司Vivado开发软件自带仿真工具，可以实现一般性能的FPGA软件仿真测试，其测试执行效率以及性能都不如第三方专用仿真软件Modelsim强。本文我们介绍下如何进行Vivado20...

体育动画直播是怎么做出来的?从数据到虚拟赛场的科技魔法!

你是否见过这样的比赛直播？没有真实球员，却能看梅西带球突破？足球比赛变成动画版，但数据100%真实？电竞比赛用虚拟形象直播，选手操作实时同步？这就是体育动画直播——一种融合实时数据、游戏引擎和AI的...

Dialogue between CPC and political parties of neighboring countries held in Beijing

BEIJING,May26(Xinhua)--TheCommunistPartyofChina(CPC)inDialoguewithPoliticalPartiesof...

一周热门
最近发表
标签列表