经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » ASP.net » 查看文章
aspnetcore插件开发dll热加载 二
来源：cnblogs　　作者：星仔007　　时间：2024/5/27 9:21:33　　对本文有异议

这一篇文章应该是个总结。

投简历的时候是不是有人问我有没有abp的开发经历，汗颜！

在各位大神的尝试及自己的总结下，还是实现了业务和主机服务分离，通过dll动态的加载卸载，控制器动态的删除添加。

项目如下：

 

演示效果：

 

下面就是代码部分：

重点

1.IActionDescriptorChangeProvider接口，(关于添加删除可以通过后台任务检测刷新，移除控制器操作)

2.builder.Services.AddControllers().ConfigureApplicationPartManager和AssemblyLoadContext搭配加载业务的dll（动态链接库）。

我的业务代码很简单，可能有人要说了，那复杂的业务，有很多业务类，注入这块怎么办，怎么实现整个的调用链。

关于业务和主服务之间的关联代码就在这了

  1. namespace ModuleLib
  2. {
  3.     //可以给个抽象类，默认实现。否则各个服务每次实现接口会多做一步删除为实现接口的动作
  4.     public interface IModule
  5.     {
  6.         void ConfigureService(IServiceCollection services, IConfiguration configuration=null);
  7.         void Configure(IApplicationBuilder app, IWebHostEnvironment env = null);
  8.     } 
  9. }

 

看下面的项目，有没有一点模块化开发的感觉，但是这次分离的很彻底，只需要dll就行，不需要程序集引用。

  1. {
  2.   "Modules": [
  3.     {
  4.       "id": "FirstWeb",
  5.       "version": "1.0.0",
  6.       "path": "C:\\Users\\victor.liu\\Documents\\GitHub\\AspNetCoreSimpleAop\\LastModule\\FirstWeb\\bin\\Debug\\net8.0"
  7.     },
  8.     {
  9.       "id": "SecondService",
  10.       "version": "1.0.0",
  11.       "path": "C:\\Users\\victor.liu\\Documents\\GitHub\\AspNetCoreSimpleAop\\LastModule\\SecondService\\bin\\Debug\\net8.0"   //????csproj?????????????з???????????????????????????
  12.     }
  13.   ]
  14. }

以Assembly为单位做存储

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Reflection;
  5. using System.Text;
  6. using System.Threading.Tasks;
  8. namespace Common
  9. {
  10.     public class ModuleInfo
  11.     {
  12.         public string Id { get; set; }
  13.         public string Name { get; set; }
  14.         public Version Version { get; set; }
  15.         public string Path { get; set; } = "lib";
  16.         public Assembly Assembly { get; set; }
  17.     }
  18. }

在初次加载的时候注入Imodule，并且缓存起来，这样避免了反射的操作，之前的做法是通过反射来拿IModule

  1. using Common;
  2. using ModuleLib;
  3. using System.Reflection;
  5. namespace MainHost.ServiceExtensions
  6. {
  7.     public static class InitModuleExt
  8.     {
  9.         public static void InitModule(this IServiceCollection services,IConfiguration configuration)
  10.         {
  11.             var modules = configuration.GetSection("Modules").Get<List<ModuleInfo>>();
  12.             foreach (var module in modules)
  13.             {
  14.                 GolbalConfiguration.Modules.Add(module);
  15.                 module.Assembly = Assembly.LoadFrom($"{module.Path}\\{module.Id}.dll"); //测试才这么写
  16.  
  17.                 var moduleType = module.Assembly.GetTypes().FirstOrDefault(t => typeof(IModule).IsAssignableFrom(t));
  18.                 if ((moduleType != null) && (moduleType != typeof(IModule)))
  19.                 {
  20.                     services.AddSingleton(typeof(IModule), moduleType);
  21.                 }
  22.             }
  23.         }
  24.     }
  25. }

 

再看看Program是怎么写的，等等，为什么注释掉了重要的代码呢

  1. using BigHost;
  2. using BigHost.AssemblyExtensions;
  3. using Common;
  4. using Microsoft.AspNetCore.Mvc;
  5. using Microsoft.AspNetCore.Mvc.ApplicationParts;
  6. using Microsoft.AspNetCore.Mvc.Infrastructure;
  7. using Microsoft.Extensions.Configuration;
  8. using ModuleLib;
  9. using System.Xml.Linq;
  10. using DependencyInjectionAttribute;
  12. var builder = WebApplication.CreateBuilder(args);
  13. builder.Configuration.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
  14. builder.Configuration.AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json", optional: true, reloadOnChange: true);
  15. builder.Configuration.AddJsonFile("appsettings.Modules.json", optional: false, reloadOnChange: true);
  16. //builder.Services.InitModule(builder.Configuration);
  17. //var sp = builder.Services.BuildServiceProvider();
  18. //var modules = sp.GetServices<IModule>();
  19. // Add services to the container.
  20. // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
  21. builder.Services.AddEndpointsApiExplorer();
  22. builder.Services.AddSwaggerGen();
  24. //最新dotnet没有这些
  25. builder.Services.AddControllers().ConfigureApplicationPartManager(apm =>
  26. {
  27.     var context = new CollectibleAssemblyLoadContext();
  28.     DirectoryInfo DirInfo = new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), "lib"));
  29.     foreach (var file in DirInfo.GetFiles("*.dll"))
  30.     {
  31.         //if(!(file.Name.Contains("Test001Controller") || file.Name.Contains("Test002Controller")))
  32.         //{
  33.         //    continue;
  34.         //}//不能屏蔽掉依赖引用
  35.         var assembly = context.LoadFromAssemblyPath(file.FullName);
  36.         var controllerAssemblyPart = new AssemblyPart(assembly);
  37.         apm.ApplicationParts.Add(controllerAssemblyPart);
  38.         ExternalContexts.Add(file.Name, context);
  39.     }
  40. });
  41.     //builder.Services.AddTransient<IProductBusiness, ProductBusiness>();
  42.     //foreach (var module in modules)
  43.     //{
  44.     //    module.ConfigureService(builder.Services, builder.Configuration);
  45.     //}
  46.     //GolbalConfiguration.Modules.Select(x => x.Assembly).ToList().ForEach(x =>
  47.     //{
  48.     //    builder.Services.ReisterServiceFromAssembly(x);
  49.     //    var controllerAssemblyPart = new AssemblyPart(x);
  50.     //    apm.ApplicationParts.Add(controllerAssemblyPart);
  51.     //    ExternalContexts.Add(x.GetName().Name, context);
  52.     //});
  53. //});
  54. //GolbalConfiguration.Modules.Select(x => x.Assembly).ToList().ForEach(x => builder.Services.ReisterServiceFromAssembly(x));
  55. builder.Services.AddSingleton<IActionDescriptorChangeProvider>(ActionDescriptorChangeProvider.Instance);
  56. builder.Services.AddSingleton(ActionDescriptorChangeProvider.Instance);
  60. var app = builder.Build();
  61. ServiceLocator.Instance = app.Services;
  62. //foreach (var module in modules)
  63. //{
  64. //    module.Configure(app, app.Environment);
  65. //}
  67. // Configure the HTTP request pipeline.
  68. if (app.Environment.IsDevelopment())
  69. {
  70.     app.UseSwagger();
  71.     app.UseSwaggerUI();
  72. }
  73. app.UseHttpsRedirection();
  76. app.MapGet("/Add", ([FromServices] ApplicationPartManager _partManager, string name) =>
  77. {
  79.     FileInfo FileInfo = new FileInfo(Path.Combine(Directory.GetCurrentDirectory(), "lib/" + name + ".dll"));
  80.     using (FileStream fs = new FileStream(FileInfo.FullName, FileMode.Open))
  81.     {
  82.         var context = new CollectibleAssemblyLoadContext();
  83.         var assembly = context.LoadFromStream(fs);
  84.         var controllerAssemblyPart = new AssemblyPart(assembly);
  86.         _partManager.ApplicationParts.Add(controllerAssemblyPart);
  88.         //ExternalContexts.Add(name + ".dll", context);
  89.         ExternalContexts.Add(name, context);
  91.         //更新Controllers
  92.         ActionDescriptorChangeProvider.Instance.HasChanged = true;
  93.         ActionDescriptorChangeProvider.Instance.TokenSource!.Cancel();
  94.     }
  95.     return "添加{name}controller成功";
  96. })
  97. .WithTags("Main")
  98. .WithOpenApi();
  100. app.MapGet("/Remove", ([FromServices] ApplicationPartManager _partManager, string name) =>
  101. {
  102.     //if (ExternalContexts.Any(
  103.     //    $"{name}.dll"))
  104.     if (ExternalContexts.Any(
  105.    $"{name}"))
  106.     {
  107.         var matcheditem = _partManager.ApplicationParts.FirstOrDefault(x => x.Name == name);
  108.         if (matcheditem != null)
  109.         {
  110.             _partManager.ApplicationParts.Remove(matcheditem);
  111.             matcheditem = null;
  112.         }
  113.         ActionDescriptorChangeProvider.Instance.HasChanged = true;
  114.         ActionDescriptorChangeProvider.Instance.TokenSource!.Cancel();
  115.         //ExternalContexts.Remove(name + ".dll");
  116.         ExternalContexts.Remove(name);
  117.         return $"成功移除{name}controller";
  118.     }
  119.     else
  120.     {
  121.         return "$没有{name}controller";
  122.     }
  123. });
  124. app.UseRouting(); //最新dotnet没有这些
  125. app.MapControllers();  //最新dotnet没有这些
  126. app.Run();

 

这里先对上面的尝试做个总结:

模块化开发通过IModule分离各个模块解耦，通过dll把接口加入到主程序，很nice,但是，我还想更深入一层，把这个接口也一并做成可拔可插，这样就不得不考虑如何动态的重载controller，这也没问题。重中之重来了，上面的都做到了，但是我要的不仅仅是增加删除一个controller，关联的业务代码发生了改变如何重载刷新，依赖注入这一块绕不过去。并没有好的解决办法，就这样项目戛然而止。

目前有两种解决办法：

1.加个中间层，通过反射去动态获取业务实现

2.业务实现通过new对象来拿。

下面是代码：

  1. using IOrder.Repository;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using Microsoft.Extensions.DependencyInjection;
  8. using System.Reflection;
  9. using System.Runtime.Loader;
  11. namespace AutofacRegister
  12. {
  13.     public interface IRepositoryProvider
  14.     {
  15.         IRepository GetRepository(string serviceeName);
  16.     }
  17.     public class RepositoryProvider : IRepositoryProvider
  18.     {
  19.         private readonly Dictionary<string, (Assembly assembly, DateTime lastModified)> _assemblyCache = new Dictionary<string, (Assembly assembly, DateTime lastModified)>();
  20.         private readonly Dictionary<string, IRepository> _typeCache = new Dictionary<string, IRepository>();
  22.         public IRepository GetRepository(string serviceName)
  23.         {
  24.             var path = $"{Directory.GetCurrentDirectory()}\\lib\\{serviceName}.Repository.dll";
  25.             var lastModified = File.GetLastWriteTimeUtc(path);
  26.             if (_assemblyCache.TryGetValue(path, out var cachedEntry) && cachedEntry.lastModified == lastModified)
  27.             {
  28.                 // 使用缓存中的 Assembly 对象
  29.                 return CreateInstanceFromAssembly(cachedEntry.assembly,serviceName);
  30.             }
  31.             else
  32.             {
  33.                 // 加载并缓存新的 Assembly 对象
  34.                 var assembly = LoadAssemblyFromFile(path);
  35.                 _assemblyCache[path] = (assembly, lastModified);
  36.                 return CreateInstanceFromAssembly(assembly,serviceName);
  37.             }
  38.         }
  40.         private Assembly LoadAssemblyFromFile(string path)
  41.         {
  42.             var _AssemblyLoadContext = new AssemblyLoadContext(Guid.NewGuid().ToString("N"), true);
  43.             using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read))
  44.             {
  45.                 return _AssemblyLoadContext.LoadFromStream(fs);
  46.             }
  47.         }
  48.         private IRepository CreateInstanceFromAssembly(Assembly assembly,string serviceName)
  49.         {
  50.             var  type_key = $"{assembly.FullName}_{serviceName}";
  51.             if(_typeCache.TryGetValue(type_key, out var cachedType))
  52.             {
  53.                 return _typeCache[type_key];
  54.             }
  55.             var type = assembly.GetTypes()
  56.                 .Where(t => typeof(IRepository).IsAssignableFrom(t) && !t.IsInterface)
  57.                 .FirstOrDefault();
  59.             if (type != null)
  60.             {
  61.                 var instance= (IRepository)Activator.CreateInstance(type);
  62.                 _typeCache[type_key] = instance;
  63.                 return instance;
  64.             }
  65.             else
  66.             {
  67.                 throw new InvalidOperationException("No suitable type found in the assembly.");
  68.             }
  69.         }
  70.     }
  71. }

 

所有的注入业务放到单独的注入文件中，

  1. using Autofac;
  2. using IOrder.Repository;
  3. using Order.Repository;
  5. namespace AutofacRegister
  6. {
  7.     public class RepositoryModule:Module
  8.     {
  9.         protected override void Load(ContainerBuilder builder)
  10.         {
  11.             //builder.RegisterType<Repository>().As<IRepository>().SingleInstance();
  12.             builder.RegisterType<RepositoryProvider>().As<IRepositoryProvider>().InstancePerLifetimeScope();
  13.         }
  14.     }
  15. }

 

上面的代码可以再加一层代理，类似这样

  1. using CustomAttribute;
  2. using System.Reflection;
  3. using ZURU_ERP.Base.Common.UnitOfWork;
  4. using ZURU_ERP.Base.Common;
  5. using ZURU_ERP.Base.Model;
  6. using System.Collections.Concurrent;
  8. namespace ZURU_ERP.Base.Reflect
  9. {
  10.     public class MethodInfoCache
  11.     {
  12.         public string Name { get; set; }
  13.         public Type ClassType { get; set; }
  14.         public CusTransAttribute TransAttribute { get; set; }
  16.         public List<CusActionAttribute> ActionAttributes { get; set; }
  17.         public bool UseTrans => (TransAttribute == null);
  18.         public bool UseAop => ActionAttributes.Any();
  19.     }
  20.     public class CusProxyGenerator<T> : DispatchProxy where T:class
  21.     {
  23.         private readonly ConcurrentDictionary<string, MethodInfoCache> _cache = new ConcurrentDictionary<string, MethodInfoCache>();
  24.         private IBusiness<T> business;
  25.         private  List<ICusAop> cusAop;
  27.         protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
  28.         {
  29.             #region 缓存优化 未经过测试
  30.             string methodKey = targetMethod.Name;
  31.             if (!_cache.ContainsKey(methodKey))
  32.             {
  33.                 var classType = business.GetType();
  34.                 var transAttribute = classType.GetMethod(targetMethod.Name).GetCustomAttributes<CusTransAttribute>().FirstOrDefault();
  35.                 var actionAttributes = classType.GetMethod(targetMethod.Name).GetCustomAttributes<CusActionAttribute>().ToList();
  36.                 _cache[methodKey] = new MethodInfoCache()
  37.                 {
  38.                     Name = methodKey,
  39.                     ClassType = classType,
  40.                     TransAttribute = transAttribute,
  41.                     ActionAttributes = actionAttributes
  42.                 };
  43.             }
  44.             var methodInfoCache = _cache[methodKey];
  45.             object result;
  46.             if (methodInfoCache.UseAop)
  47.             {
  48.                 var actionnames = methodInfoCache.ActionAttributes.Select(x => x.Name).ToList();
  49.                 var waitInvokes = cusAop.Where(x => actionnames.Contains(x.GetType().Name)).OrderBy(x => actionnames.IndexOf(x.GetType().Name)).ToList(); //排序
  50.                 foreach (var item in waitInvokes)
  51.                 {
  52.                     item.Before(args);
  53.                 }
  55.                 result = methodInfoCache.UseTrans ? Trans(targetMethod, args, out result) : targetMethod.Invoke(business, args);
  56.                 foreach (var item in waitInvokes)
  57.                 {
  58.                     item.After(new object[] { result });
  59.                 }
  60.                 return result;
  61.             }
  62.             else
  63.             {
  64.                 return methodInfoCache.UseTrans ? Trans(targetMethod, args, out result) : targetMethod.Invoke(business, args);
  65.             } 
  66.             #endregion
  67.  
  68.             #region 没缓存原代码 经过测试
  69.  
  70.             //bool useTran = false;
  71.             //var classType = business.GetType();
  72.             //var useClassTrans = classType.GetCustomAttributes<CusTransAttribute>();
  73.             //if (useClassTrans.Any())
  74.             //{
  75.             //    useTran = true;
  76.             //}
  77.             //else
  78.             //{
  79.             //    useTran = classType.GetMethod(targetMethod.Name).GetCustomAttributes<CusTransAttribute>().Any();  //是否使用事务
  80.             //}
  82.             //var actionnames = classType.GetCustomAttributes<CusActionAttribute>().Select(x => x.Name).ToList();
  84.             //var waitInvokes = cusAop.Where(x => actionnames.Contains(x.GetType().Name)).OrderBy(x => actionnames.IndexOf(x.GetType().Name)).ToList(); //排序
  86.             //foreach (var item in waitInvokes)
  87.             //{
  88.             //    item.Before(args);
  89.             //}
  91.             //object result;
  92.             //if (useTran)
  93.             //{
  94.             //    return Trans(targetMethod, args, out result);
  95.             //}
  96.             //else
  97.             //{
  98.             //    result = targetMethod.Invoke(business, args);
  99.             //}
  101.             //foreach (var item in waitInvokes)
  102.             //{
  103.             //    item.After(new object[] { result });
  104.             //}
  106.             //return result;
  107.             #endregion
  108.         }
  110.         private object? Trans(MethodInfo? targetMethod, object?[]? args, out object result)
  111.         {
  112.             var _unitOfWorkManage = App.GetService<IUnitOfWorkManage>();
  114.             Console.WriteLine($"{targetMethod.Name} transaction started.");
  116.             try
  117.             {
  118.                 if (_unitOfWorkManage.TranCount <= 0)
  119.                 {
  120.                     Console.WriteLine($"Begin Transaction");
  121.                     _unitOfWorkManage.BeginTran();
  122.                 }
  123.                 result = targetMethod.Invoke(business, args);
  124.                 if (result is ApiResult apiResult && !apiResult.success)
  125.                 {
  126.                     Console.WriteLine("apiResult return false Transaction rollback.");
  127.                     _unitOfWorkManage.RollbackTran();
  128.                     return apiResult;
  129.                 }
  130.                 if (_unitOfWorkManage.TranCount > 0)
  131.                     _unitOfWorkManage.CommitTran();
  132.                 Console.WriteLine("Transaction Commit.");
  133.                 Console.WriteLine($"{targetMethod.Name}  transaction succeeded.");
  135.                 return result;
  136.             }
  137.             catch (Exception e)
  138.             {
  139.                 _unitOfWorkManage.RollbackTran();
  140.                 Console.WriteLine("Transaction Rollback.");
  141.                 Console.WriteLine($"{targetMethod.Name}  transaction failed: " + e.Message);
  142.                 throw;
  143.             }
  144.         }
  146.         public static IBusiness<T> Create(IBusiness<T> business, List<ICusAop> cusAop)
  147.         {
  148.             object proxy = Create<IBusiness<T>, CusProxyGenerator<T>>();
  149.             ((CusProxyGenerator<T>)proxy).SetParameters(business, cusAop);
  150.             return (IBusiness<T>)proxy;
  151.         }
  153.         private void SetParameters(IBusiness<T> business, List<ICusAop> cusAop)
  154.         {
  155.             this.business = business;
  156.             this.cusAop = cusAop;
  157.         }
  158.     }
  159. }

 

由于这层代码没有走依赖注入，想用各种aop组件，灵活性稍微低了一点点。

下面第二种直接在业务代码中new对象也不是不可，这一层的前后需要的都可以注入到容器里面去。只不过这一层就想到包装类一层不要在使用这个类的时候做过多的职责承担

  1. using IBusiness;
  3. namespace Business
  4. {
  5.     public class ProductBusiness : IDisposable// : IProductBusiness
  6.     {
  7.         public static readonly ProductBusiness Instance;
  8.         private bool _disposed = false; 
  9.         static ProductBusiness()
  10.         {
  11.             Instance = new ProductBusiness();
  12.         }
  13.       
  14.         private ProductBusiness()
  15.         {
  16.             // 初始化资源
  17.         }
  18.         public async Task<int> AddProduct(string name, decimal price)
  19.         {
  20.             await Task.CompletedTask;
  21.             return 1;
  22.         }
  24.         // 实现IDisposable接口
  25.         public void Dispose()
  26.         {
  27.             Dispose(true);
  28.             GC.SuppressFinalize(this);
  29.         }
  31.         protected virtual void Dispose(bool disposing)
  32.         {
  33.             if (_disposed)
  34.                 return;
  36.             if (disposing)
  37.             {
  38.                 // 释放托管资源
  39.             }
  41.             // 释放非托管资源
  42.             _disposed = true;
  43.         }
  45.         // 析构函数
  46.         ~ProductBusiness()
  47.         {
  48.             Dispose(false);
  49.         }
  50.     }
  51. }

使用的时候就直接拿实例：

  1.   [HttpPost]
  2.   public async Task<int> Add()
  3.   {
  4.       //using var scope = ServiceLocator.Instance.CreateScope();
  5.       //var business = scope.ServiceProvider.GetRequiredService<IProductBusiness>();
  6.       using var business = ProductBusiness.Instance;
  7.       return await business.AddProduct("product1",12.1m);
  8.   }

 

demo源代码：

liuzhixin405/AspNetCoreSimpleAop (github.com)

 

原文链接：https://www.cnblogs.com/morec/p/18211276

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

ASP.net热门文章

  • 【Dotnet 工具箱】WPF UI - 现代化设计的开源 WPF 框架
  • net core 使用 SqlSugar
  • .NETCore下CI/CD之自动化测试
  • .net core部署到linux可能碰到的问题
  • Abp vNext 自定义 Ef Core 仓储引发异常
  • .NetCore 消息队列的使用
  • .NetCore WebApi——基于JWT的简单身份认证与授权（Swagger）
  • Abp.NHibernate连接PostgreSQl数据库
  • ModelValidator基于元数据的验证
  • .NET MAUI 安卓应用开发初体验

    • ASP.net推荐文章

  • Gradio.NET 支持 .NET 8 简化 Web 应用开发
  • .NET 轻量化定时任务调度 FreeScheduler
  • WPF 模仿前端大佬写一个Hover效果
  • WPF 模拟UWP原生窗口样式——亚克力|云母材质、自定义标题栏样式、原生DWM动画 （附我封装好的类）
  • .NET 音频采集
  • .NET8 Blazor 从入门到精通：（三）类库和表单
  • wpf 如何7步写一个badge控件
  • .NET 高效Nuget管理工具（开源）
  • .NET 8 跨平台高性能边缘采集网关
  • .NET 窗口/屏幕录制

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号