簡介
開講第二篇，本篇程式碼並非Copy的ABP,只是參考ABP的功能，進行的實現方案，讓程式碼更加通俗易懂。程式碼的講解思路和上一篇一樣，但是不引用上篇的寫法。
開始
第一步 基本操作
還是老樣子，我們新建一個模組化介面類
新建介面 IAppModule (ps:專案中起的類名和方法名儘量對標ABP)
/// <summary>
/// 應用模組介面定義
/// </summary>
public interface IAppModule
{
/// <summary>
/// 配置服務前
/// </summary>
/// <param name="context"></param>
void OnPreConfigureServices();
/// <summary>
/// 配置服務
/// </summary>
/// <param name="context">配置上下文</param>
void OnConfigureServices();
/// <summary>
/// 配置服務後
/// </summary>
/// <param name="context"></param>
void OnPostConfigureServices();
/// <summary>
/// 應用啟動前
/// </summary>
/// <param name="context"></param>
void OnPreApplicationInitialization();
/// <summary>
/// 應用啟動
/// </summary>
/// <param name="context"></param>
void OnApplicationInitialization();
/// <summary>
/// 應用啟動後
/// </summary>
/// <param name="context"></param>
void OnPostApplicationInitialization();
/// <summary>
/// 應用停止
/// </summary>
/// <param name="context"></param>
void OnApplicationShutdown();
}
新建類 AppModule 繼承 IAppModule
public abstract class AppModule : IAppModule
{
public virtual void OnPreConfigureServices()
{
}
public virtual void OnConfigureServices()
{
}
public virtual void OnPostConfigureServices()
{
}
public virtual void OnPreApplicationInitialization()
{
}
public virtual void OnApplicationInitialization()
{
}
public virtual void OnPostApplicationInitialization()
{
}
public virtual void OnApplicationShutdown()
{
}
}
第二步 預準備
這一步來完成ABP的DependsOnAttribute，通過特性進行引入模組，
這裡引數 params Type[] 因為一個模組會依賴多個模組
新建類 DependsOnAttribute 繼承 Attribute
/// <summary>
/// 模組依賴的模組
/// </summary>
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class DependsOnAttribute : Attribute
{
/// <summary>
/// 依賴的模組型別
/// </summary>
public Type[] DependModuleTypes { get; private set; }
public DependsOnAttribute(params Type[] dependModuleTypes)
{
DependModuleTypes = dependModuleTypes ?? new Type[0];
}
}
既然一個模組會包含多個模組的引用，那麼就應該有一個儲存的方式
新建類 ModuleDescriptor 該類來儲存 自身和引用的其他模組
/// <summary>
/// 模組描述
/// </summary>
public class ModuleDescriptor
{
private object _instance;
/// <summary>
/// 模組型別
/// </summary>
public Type ModuleType { get; private set; }
/// <summary>
/// 依賴項
/// </summary>
public ModuleDescriptor[] Dependencies { get; private set; }
/// <summary>
/// 例項
/// </summary>
public object Instance
{
get
{
if (this._instance == null)
{
this._instance = Activator.CreateInstance(this.ModuleType);
}
return this._instance;
}
}
public ModuleDescriptor(Type moduleType, params ModuleDescriptor[] dependencies)
{
this.ModuleType = moduleType;
// 如果模組依賴 為空給一個空陣列
this.Dependencies = dependencies ?? new ModuleDescriptor[0];
}
}
第三步 模組管理器
來到核心步驟，這裡我們寫模組管理器，白話就是儲存模組和模組操作方法的一個類(同上一篇的StartupModulesOptions)
第一步肯定是模組的啟動
我們新建 IModuleManager介面
public interface IModuleManager : IDisposable
{
/// <summary>
/// 啟動模組
/// </summary>
/// <typeparam name="TModule"></typeparam>
void StartModule<TModule>(IServiceCollection services)
where TModule : IAppModule;
}
緊跟新建類 ModuleManager 繼承 IModuleManager， StartModule 先放在一邊
這裡的思路是：模組是從一個入口的根模組開始的慢慢的形成一個樹狀的引用關係，我們首先需要拿到所有的模組引用，並把他們從樹葉為起點排列起來，依次注入。
(理解為A=>B=>C 那麼注入的順序應該是 C=>B=>A)
1.先來實現根絕入口遞迴獲取所有的引用關係 我已經在方法中將每一步的註釋都寫上了
/// <summary>
/// 獲取模組依賴樹
/// </summary>
/// <param name="moduleType"></param>
/// <returns></returns>
protected virtual List<ModuleDescriptor> VisitModule(Type moduleType) {
var moduleDescriptors = new List<ModuleDescriptor>();
// 是否必須被重寫|是否是介面|是否為泛型型別|是否是一個類或委託
if (moduleType.IsAbstract || moduleType.IsInterface || moduleType.IsGenericType || !moduleType.IsClass) {
return moduleDescriptors;
}
// 過濾沒有實現IRModule介面的類
var baseInterfaceType = moduleType.GetInterface(_moduleInterfaceTypeFullName, false);
if (baseInterfaceType == null)
{
return moduleDescriptors;
}
// 得到當前模組依賴了那些模組
var dependModulesAttribute = moduleType.GetCustomAttribute<DependsOnAttribute>();
// 依賴屬性為空
if (dependModulesAttribute == null)
{
moduleDescriptors.Add(new ModuleDescriptor(moduleType));
}
else {
// 依賴屬性不為空,遞迴獲取依賴
var dependModuleDescriptors = new List<ModuleDescriptor>();
foreach (var dependModuleType in dependModulesAttribute.DependModuleTypes)
{
dependModuleDescriptors.AddRange(
VisitModule(dependModuleType)
);
}
// 建立模組描述資訊,內容為模組型別和依賴型別
moduleDescriptors.Add(new ModuleDescriptor(moduleType, dependModuleDescriptors.ToArray()));
}
return moduleDescriptors;
}
補： _moduleInterfaceTypeFullName 定義
/// <summary>
/// 模組介面型別全名稱
/// </summary>
public static string _moduleInterfaceTypeFullName = typeof(IAppModule).FullName;
2.拿到依賴關係通過拓撲排序進行順序處理 (ps：拓撲排序地址 https://www.cnblogs.com/myzony/p/9201768.html)
新建類 Topological 這塊沒啥特別要講的根據連結去看下就好了
/// <summary>
/// 拓撲排序工具類
/// </summary>
public static class Topological
{
public static List<T> Sort<T>(IEnumerable<T> source, Func<T, IEnumerable<T>> getDependencies) {
var sorted = new List<T>();
var visited = new Dictionary<T, bool>();
foreach (var item in source)
{
Visit(item, getDependencies, sorted, visited);
}
return sorted;
}
static void Visit<T>(T item, Func<T, IEnumerable<T>> getDependencies, List<T> sorted, Dictionary<T, bool> visited)
{
bool inProcess;
var alreadyVisited = visited.TryGetValue(item, out inProcess);
// 如果已經訪問該頂點，則直接返回
if (alreadyVisited)
{
// 如果處理的為當前節點，則說明存在迴圈引用
if (inProcess)
{
throw new ArgumentException("模組出現迴圈依賴.");
}
}
else
{
// 正在處理當前頂點
visited[item] = true;
// 獲得所有依賴項
var dependencies = getDependencies(item);
// 如果依賴項集合不為空，遍歷訪問其依賴節點
if (dependencies != null)
{
foreach (var dependency in dependencies)
{
// 遞迴遍歷訪問
Visit(dependency, getDependencies, sorted, visited);
}
}
// 處理完成置為 false
visited[item] = false;
sorted.Add(item);
}
}
}
回到 ModuleManager 新建方法 ModuleSort
/// <summary>
/// 模組排序
/// </summary>
/// <typeparam name="TModule"></typeparam>
/// <returns></returns>
public virtual List<ModuleDescriptor> ModuleSort<TModule>() where TModule : IAppModule
{
// 得到模組樹依賴
var moduleDescriptors = VisitModule(typeof(TModule));
// 因為現在得到的資料是從樹根開始到樹葉 - 實際的注入順序應該是從樹葉開始 所以這裡需要對模組進行排序
return Topological.Sort(moduleDescriptors, o => o.Dependencies);
}
補：ModuleSort本來是個私有方法 後為了讓模組使用者可以實現重寫，請在 IModuleManager 加入
/// <summary>
/// 模組排序
/// </summary>
/// <typeparam name="TModule">啟動模組型別</typeparam>
/// <returns>排序結果</returns>
List<ModuleDescriptor> ModuleSort<TModule>()
where TModule : IAppModule;
3.模組已經可以通過方法拿到了就來實現 StartModule 方法 篩選去重 依次進行注入， 並最終儲存到全域性物件中
/// <summary>
/// 模組明細和例項
/// </summary>
public virtual IReadOnlyList<ModuleDescriptor> ModuleDescriptors { get; protected set; }
/// <summary>
/// 入口 StartModule
/// 我們通過傳遞泛型進來的 TModule 為起點
/// 查詢他的依賴樹
/// </summary>
/// <typeparam name="TModule"></typeparam>
/// <param name="services"></param>
public void StartModule<TModule>(IServiceCollection services) where TModule : IAppModule
{
var moduleDescriptors = new List<ModuleDescriptor>();
var moduleDescriptorList = this.ModuleSort<TModule>();
// 去除重複的引用 進行注入
foreach (var item in moduleDescriptorList)
{
if (moduleDescriptors.Any(o => o.ModuleType.FullName == item.ModuleType.FullName))
{
continue;
}
moduleDescriptors.Add(item);
services.AddSingleton(item.ModuleType, item.Instance);
}
ModuleDescriptors = moduleDescriptors.AsReadOnly();
}
4.ModuleDescriptors既然儲存著我們的所有模組，那麼我們怎麼執行模組的方法呢
入口通過呼叫下面的方法進行模組的方法呼叫
/// <summary>
/// 進行模組的 ConfigurationService 方法呼叫
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
/// <returns></returns>
public IServiceCollection ConfigurationService(IServiceCollection services, IConfiguration configuration) {
foreach (var module in ModuleDescriptors)
{
(module.Instance as IAppModule)?.OnPreConfigureServices();
}
foreach (var module in ModuleDescriptors)
{
(module.Instance as IAppModule)?.OnConfigureServices();
}
foreach (var module in ModuleDescriptors)
{
(module.Instance as IAppModule)?.OnPostConfigureServices();
}
return services;
}
/// <summary>
/// 進行模組的 Configure 方法呼叫
/// </summary>
/// <param name="serviceProvider"></param>
/// <returns></returns>
public IServiceProvider ApplicationInitialization(IServiceProvider serviceProvider)
{
foreach (var module in ModuleDescriptors)
{
(module.Instance as IAppModule)?.OnPreApplicationInitialization();
}
foreach (var module in ModuleDescriptors)
{
(module.Instance as IAppModule)?.OnApplicationInitialization();
}
foreach (var module in ModuleDescriptors)
{
(module.Instance as IAppModule)?.OnPostApplicationInitialization();
}
return serviceProvider;
}
/// <summary>
/// 模組銷燬
/// </summary>
public void ApplicationShutdown()
{
// todo我覺得這裡有點問題問 易大師
//var modules = ModuleDescriptors.Reverse().ToList();
foreach (var module in ModuleDescriptors)
{
(module.Instance as IAppModule)?.OnApplicationShutdown();
}
}
當然還漏了一個模組銷燬,該方法在主模組被銷燬的時候呼叫（ps: 我個人思路應該是從樹葉開始進行，但是ABP對模組順序進行了反轉從根開始進行銷燬，所以這裡同上）
/// <summary>
/// 主模組銷燬的時候 銷燬子模組
/// </summary>
public void Dispose()
{
this.Dispose(true);
}
protected virtual void Dispose(bool state)
{
this.ApplicationShutdown();
}
第四步 Extensions
模組管理器寫完了，那麼這個方法如何呼叫呢來寫我們的 Extensions
新建 RivenModuleServiceCollectionExtensions 類，讓其完成ConfigurationService方法的模組呼叫
/// <summary>
/// 模組服務擴充套件
/// </summary>
public static class RivenModuleServiceCollectionExtensions
{
/// <summary>
/// 新增Riven模組服務
/// </summary>
/// <typeparam name="TModule"></typeparam>
/// <param name="services"></param>
/// <param name="configuration"></param>
/// <returns></returns>
public static IServiceCollection AddRivenModule<TModule>(this IServiceCollection services, IConfiguration configuration)
where TModule : IAppModule
{
var moduleManager = new ModuleManager();
// 將模組都查詢排序好
moduleManager.StartModule<TModule>(services);
// 呼叫模組 和 子模組的ConfigurationService方法
moduleManager.ConfigurationService(services, configuration);
// 注入全域性的 IModuleManager
services.TryAddSingleton<IModuleManager>(moduleManager);
return services;
}
}
新建 RivenModuleIApplicationBuilderExtensions 類 ，讓其完成Configuration方法的模組呼叫
public static class RivenModuleIApplicationBuilderExtensions
{
/// <summary>
/// 使用RivenModule
/// </summary>
/// <param name="serviceProvider"></param>
/// <returns></returns>
public static IServiceProvider UseRivenModule(this IServiceProvider serviceProvider)
{
var moduleManager = serviceProvider.GetService<IModuleManager>();
return moduleManager.ApplicationInitialization(serviceProvider);
}
}
第五步 測試
新建一個測試專案，引入寫好的模組化類庫，在 ConfigureServices 中呼叫
services.AddRivenModule<MyAppStartupModule>(Configuration);
Configure 中呼叫
app.ApplicationServices.UseRivenModule();
模組銷燬演示(ps:這個是演示效果、實際是在專案停止的時候進行。)
app.Map("/ApplicationShutdown", _ =>
{
_.Run((context) =>
{
var moduleManager = app.ApplicationServices.GetService<IModuleManager>();
moduleManager.ApplicationShutdown();
return Task.FromResult(0);
});
});
補：
新建 MyAppStartupModule、TestModuleA、TestModuleB 繼承AppModule。
MyAppStartupModule作為入口模組 引用 A => B 然後在模組方法中列印 Console.WriteLine 看效果
補充 給模組傳遞引數
新建 ApplicationInitializationContext 類
public class ApplicationInitializationContext
{
public IServiceProvider ServiceProvider { get; }
public IConfiguration Configuration { get; }
public ApplicationInitializationContext([NotNull] IServiceProvider serviceProvider, [NotNull] IConfiguration configuration)
{
ServiceProvider = serviceProvider;
Configuration = configuration;
}
}
新建 ApplicationShutdownContext 類
public class ApplicationShutdownContext
{
public IServiceProvider ServiceProvider { get; }
public ApplicationShutdownContext([NotNull] IServiceProvider serviceProvider)
{
ServiceProvider = serviceProvider;
}
}
新建 ServiceConfigurationContext 類
public class ServiceConfigurationContext
{
public IServiceCollection Services { get; protected set; }
public IConfiguration Configuration { get; protected set; }
public ServiceConfigurationContext(IServiceCollection services, IConfiguration configuration)
{
Services = services;
Configuration = configuration;
}
}
修改 IAppModule 介面, 模組和實現都自己手動都同步一下
/// <summary>
/// 應用模組介面定義
/// </summary>
public interface IAppModule
{
/// <summary>
/// 配置服務前
/// </summary>
/// <param name="context"></param>
void OnPreConfigureServices(ServiceConfigurationContext context);
/// <summary>
/// 配置服務
/// </summary>
/// <param name="context">配置上下文</param>
void OnConfigureServices(ServiceConfigurationContext context);
/// <summary>
/// 配置服務後
/// </summary>
/// <param name="context"></param>
void OnPostConfigureServices(ServiceConfigurationContext context);
/// <summary>
/// 應用啟動前
/// </summary>
/// <param name="context"></param>
void OnPreApplicationInitialization(ApplicationInitializationContext context);
/// <summary>
/// 應用啟動
/// </summary>
/// <param name="context"></param>
void OnApplicationInitialization(ApplicationInitializationContext context);
/// <summary>
/// 應用啟動後
/// </summary>
/// <param name="context"></param>
void OnPostApplicationInitialization(ApplicationInitializationContext context);
/// <summary>
/// 應用停止
/// </summary>
/// <param name="context"></param>
void OnApplicationShutdown(ApplicationShutdownContext context);
}
修改 ModuleManager的 ConfigurationService、ApplicationInitialization、ApplicationShutdown 方法給呼叫傳遞對應引數
這部分程式碼我就不貼了，會的大佬都能自己寫，想看的去我的github直接下載原始碼看吧，麻煩老闆們給點個星星！！！