生成模塊依賴(lài)樹(shù)如圖所示：

首先從 E ₀ 開(kāi)始掃描，因?yàn)?E ₀ 下存在子節(jié)點(diǎn) C ₀ 、 D ₀ ，那么就會(huì)先順著 C ₀ 再次掃描，掃描到 A ₀ 時(shí)，因?yàn)?A ₀ 下已經(jīng)沒(méi)有子節(jié)點(diǎn)了，所以會(huì)對(duì) A ₀ 對(duì)應(yīng)的模塊 A 進(jìn)行初始化。根據(jù)上圖模塊依賴(lài)樹(shù)進(jìn)行后序遍歷，初始化模塊的順序是（已經(jīng)被初始化的模塊會(huì)跳過(guò)）：

偽代碼示例如下：

		private static void InitModuleTree(ModuleNode moduleNode)
		{
			if (moduleNode.Childs != null)
			{
				foreach (var item in moduleNode.Childs)
				{
					InitModuleTree(item);
				}
			}
            
            // 如果該節(jié)點(diǎn)已經(jīng)沒(méi)有子節(jié)點(diǎn)
			// 如果模塊沒(méi)有處理過(guò)
			if (!moduleTypes.Contains(moduleNode.ModuleType))
			{
				InitInjectService(moduleNode.ModuleType);
			}
		}

實(shí)現(xiàn)模塊化和自動(dòng)服務(wù)注冊(cè)

本小節(jié)的代碼都在 ModuleExtensions.cs 中。

當(dāng)我們把接口、枚舉、特性等類(lèi)型定義之后，接下來(lái)我們便要思考如何實(shí)例化模塊、檢測(cè)模塊的依賴(lài)關(guān)系，實(shí)現(xiàn)自動(dòng)服務(wù)注冊(cè)。為了簡(jiǎn)化設(shè)計(jì)，我們可以將模塊化自動(dòng)服務(wù)注冊(cè)寫(xiě)在一起，當(dāng)初始化一個(gè)模塊時(shí)，框架同時(shí)會(huì)掃描該程序集中的服務(wù)進(jìn)行注冊(cè)。如果程序集中不包含模塊類(lèi)，那么框架不會(huì)掃描該程序集，也就不會(huì)注冊(cè)服務(wù)。

接下來(lái)，我們思考模塊化框架需要解決哪些問(wèn)題或支持哪些功能：

• 如何識(shí)別和注冊(cè)服務(wù)；

• 框架能夠識(shí)別模塊的依賴(lài)，生成模塊依賴(lài)樹(shù)，能夠檢測(cè)到循環(huán)依賴(lài)等問(wèn)題；

• 多個(gè)模塊可能引用了同一個(gè)模塊 A，但是模塊 A 只能被實(shí)例化一次；

• 初始化模塊的順序；

• 模塊類(lèi)本身要作為服務(wù)注冊(cè)到容器中，實(shí)例化模塊類(lèi)時(shí)，需要支持依賴(lài)注入，也就是說(shuō)模塊類(lèi)的構(gòu)造函數(shù)可以注入其它服務(wù)；

我們先解決第一個(gè)問(wèn)題，

因?yàn)樽詣?dòng)服務(wù)注冊(cè)是根據(jù)模塊所在的程序集掃描標(biāo)記類(lèi)，識(shí)別所有使用了 InjectOnAttribute 特性的類(lèi)型，所以我們可以先編寫(xiě)一個(gè)程序集掃描方法，該方法的功能是通過(guò)程序集掃描所有類(lèi)型，然后根據(jù)特性配置注冊(cè)服務(wù)。

/// 

/// 自動(dòng)依賴(lài)注入
/// 
/// 
/// 
/// 已被注入的服務(wù)
private static void InitInjectService(IServiceCollection services, Assembly assembly, HashSet injectTypes)
{
	// 只掃描可實(shí)例化的類(lèi)，不掃描靜態(tài)類(lèi)、接口、抽象類(lèi)、嵌套類(lèi)、非公開(kāi)類(lèi)等
	foreach (var item in assembly.GetTypes().Where(x => x.IsClass && !x.IsAbstract && !x.IsNestedPublic))
	{
		var inject = item.GetCustomAttributes().FirstOrDefault(x => x.GetType() == typeof(InjectOnAttribute)) as InjectOnAttribute;
		if (inject == null) continue;

		if (injectTypes.Contains(item)) continue;
		injectTypes.Add(item);

		// 如果需要注入自身
		if (inject.Own)
		{
			switch (inject.Lifetime)
			{
				case ServiceLifetime.Transient: services.AddTransient(item); break;
				case ServiceLifetime.Scoped: services.AddScoped(item); break;
				case ServiceLifetime.Singleton: services.AddSingleton(item); break;
			}
		}

		if (inject.Scheme == InjectScheme.None) continue;

		// 注入所有接口
		if (inject.Scheme == InjectScheme.OnlyInterfaces || inject.Scheme == InjectScheme.Any)
		{
			var interfaces = item.GetInterfaces();
			if (interfaces.Count() == 0) continue;
			switch (inject.Lifetime)
			{
				case ServiceLifetime.Transient: interfaces.ToList().ForEach(x => services.AddTransient(x, item)); break;
				case ServiceLifetime.Scoped: interfaces.ToList().ForEach(x => services.AddScoped(x, item)); break;
				case ServiceLifetime.Singleton: interfaces.ToList().ForEach(x => services.AddSingleton(x, item)); break;
			}
		}

		// 注入父類(lèi)
		if (inject.Scheme == InjectScheme.OnlyBaseClass || inject.Scheme == InjectScheme.Any)
		{
			var baseType = item.BaseType;
			if (baseType == null) throw new ArgumentException($"{item.Name} 注入模式 {nameof(inject.Scheme)} 未找到父類(lèi)！");
			switch (inject.Lifetime)
			{
				case ServiceLifetime.Transient: services.AddTransient(baseType, item); break;
				case ServiceLifetime.Scoped: services.AddScoped(baseType, item); break;
				case ServiceLifetime.Singleton: services.AddSingleton(baseType, item); break;
			}
		}
		if (inject.Scheme == InjectScheme.Some)
		{
			var types = inject.ServicesType;
			if (types == null) throw new ArgumentException($"{item.Name} 注入模式 {nameof(inject.Scheme)} 未找到服務(wù)！");
			switch (inject.Lifetime)
			{
				case ServiceLifetime.Transient: types.ToList().ForEach(x => services.AddTransient(x, item)); break;
				case ServiceLifetime.Scoped: types.ToList().ForEach(x => services.AddScoped(x, item)); break;
				case ServiceLifetime.Singleton: types.ToList().ForEach(x => services.AddSingleton(x, item)); break;
			}
		}
	}
}

定義兩個(gè)擴(kuò)展函數(shù)，用于注入入口模塊。

		/// 

		/// 注冊(cè)模塊化服務(wù)
		/// 
		/// 入口模塊
		/// 
		public static void AddModule(this IServiceCollection services)
			where TModule : IModule
		{
			AddModule(services, typeof(TModule));
		}


		/// 

		/// 注冊(cè)模塊化服務(wù)
		/// 
		/// 
		/// 入口模塊
		public static void AddModule(this IServiceCollection services, Type startupModule)
		{
			if (startupModule?.GetInterface(nameof(IModule)) == null)
			{
				throw new TypeLoadException($"{startupModule?.Name} 不是有效的模塊類(lèi)");
			}

			IServiceProvider scope = BuildModule(services, startupModule);
		}

框架需要從入口模塊程序集開(kāi)始查找被依賴(lài)的模塊程序集，然后通過(guò)后序遍歷初始化每個(gè)模塊，并掃描該模塊程序集中的服務(wù)。

創(chuàng)建一個(gè) BuildModule 函數(shù)，BuildModule 為構(gòu)建模塊依賴(lài)樹(shù)、初始化模塊提前創(chuàng)建環(huán)境。

		/// 

		/// 構(gòu)建模塊依賴(lài)樹(shù)并初始化模塊
		/// 
		/// 
		/// 
		/// 
		/// 
		private static IServiceProvider BuildModule(IServiceCollection services, Type startupModule)
		{
			// 生成根模塊
			ModuleNode rootTree = new ModuleNode()
			{
				ModuleType = startupModule,
				Childs = new HashSet()
			};

			// 根模塊依賴(lài)的其他模塊
			// IModule => InjectModuleAttribute
			var rootDependencies = startupModule.GetCustomAttributes(false)
				.Where(x => x.GetType().IsSubclassOf(typeof(InjectModuleAttribute)))
				.OfType();

			// 構(gòu)建模塊依賴(lài)樹(shù)
			BuildTree(services, rootTree, rootDependencies);

			// 構(gòu)建一個(gè) Ioc 實(shí)例，以便初始化模塊類(lèi)
			var scope = services.BuildServiceProvider();

			// 初始化所有模塊類(lèi)
			var serviceContext = new ServiceContext(services, scope.GetService()!);

			// 記錄已經(jīng)處理的程序集、模塊和服務(wù)，以免重復(fù)處理
			HashSet moduleAssemblies = new HashSet { startupModule.Assembly };
			HashSet moduleTypes = new HashSet();
			HashSet injectTypes = new HashSet();

            // 后序遍歷樹(shù)并初始化每個(gè)模塊
			InitModuleTree(scope, serviceContext, moduleAssemblies, moduleTypes, injectTypes, rootTree);

			return scope;
		}

第一步，構(gòu)建模塊依賴(lài)樹(shù)。

		/// 

		/// 構(gòu)建模塊依賴(lài)樹(shù)
		/// 
		/// 
		/// 
		/// 其依賴(lài)的模塊
		private static void BuildTree(IServiceCollection services, ModuleNode currentNode, IEnumerable injectModules)
		{
			services.AddTransient(currentNode.ModuleType);
			if (injectModules == null || injectModules.Count() == 0) return;
			foreach (var childModule in injectModules)
			{
				var childTree = new ModuleNode
				{
					ModuleType = childModule.ModuleType,
					ParentModule = currentNode
				};

				// 循環(huán)依賴(lài)檢測(cè)
				// 檢查當(dāng)前模塊(parentTree)依賴(lài)的模塊(childTree)是否在之前出現(xiàn)過(guò)，如果是，則說(shuō)明是循環(huán)依賴(lài)
				var isLoop = currentNode.ContainsTree(childTree);
				if (isLoop)
				{
					throw new OverflowException($"檢測(cè)到循環(huán)依賴(lài)引用或重復(fù)引用！{currentNode.ModuleType.Name} 依賴(lài)的 {childModule.ModuleType.Name} 模塊在其父模塊中出現(xiàn)過(guò)！");
				}

				if (currentNode.Childs == null)
				{
					currentNode.Childs = new HashSet();
				}

				currentNode.Childs.Add(childTree);
				// 子模塊依賴(lài)的其他模塊
				var childDependencies = childModule.ModuleType.GetCustomAttributes(inherit: false)
					.Where(x => x.GetType().IsSubclassOf(typeof(InjectModuleAttribute))).OfType().ToHashSet();
				// 子模塊也依賴(lài)其他模塊
				BuildTree(services, childTree, childDependencies);
			}
		}

通過(guò)后序遍歷識(shí)別依賴(lài)時(shí)，由于一個(gè)模塊可能會(huì)出現(xiàn)多次，所以初始化時(shí)需要判斷模塊是否已經(jīng)初始化，然后對(duì)模塊進(jìn)行初始化并掃描模塊程序集中所有的類(lèi)型，進(jìn)行服務(wù)注冊(cè)。

		/// 

		/// 從模塊樹(shù)中遍歷
		/// 
		/// 
		/// 
		/// 已經(jīng)被注冊(cè)到容器中的模塊類(lèi)
		/// 模塊類(lèi)所在的程序集'
		/// 已被注冊(cè)到容器的服務(wù)
		/// 模塊節(jié)點(diǎn)
		private static void InitModuleTree(IServiceProvider serviceProvider,
			ServiceContext context,
			HashSet moduleAssemblies,
			HashSet moduleTypes,
			HashSet injectTypes,
			ModuleNode moduleNode)
		{
			if (moduleNode.Childs != null)
			{
				foreach (var item in moduleNode.Childs)
				{
					InitModuleTree(serviceProvider, context, moduleAssemblies, moduleTypes, injectTypes, item);
				}
			}

			// 如果模塊沒(méi)有處理過(guò)
			if (!moduleTypes.Contains(moduleNode.ModuleType))
			{
				moduleTypes.Add(moduleNode.ModuleType);

				// 實(shí)例化此模塊
				// 掃描此模塊（程序集）中需要依賴(lài)注入的服務(wù)
				var module = (IModule)serviceProvider.GetRequiredService(moduleNode.ModuleType);
				module.ConfigureServices(context);
				InitInjectService(context.Services, moduleNode.ModuleType.Assembly, injectTypes);
				moduleAssemblies.Add(moduleNode.ModuleType.Assembly);
			}
		}

至此，Maomi.Core 所有的代碼都已經(jīng)講解完畢，通過(guò)本章的實(shí)踐，我們擁有了一個(gè)具有模塊化和自動(dòng)服務(wù)注冊(cè)的框架。可是，別高興得太早，我們應(yīng)當(dāng)如何驗(yàn)證框架是可靠的呢？答案是單元測(cè)試。在完成 Maomi.Core 項(xiàng)目之后，筆者立即編寫(xiě)了 Maomi.Core.Tests 單元測(cè)試項(xiàng)目，只有當(dāng)單元測(cè)試全部通過(guò)之后，筆者才能自信地把代碼放到書(shū)中。為項(xiàng)目編寫(xiě)單元測(cè)試是一個(gè)好習(xí)慣，尤其是對(duì)框架類(lèi)的項(xiàng)目，我們需要編寫(xiě)大量的單元測(cè)試驗(yàn)證框架的可靠性，同時(shí)單元測(cè)試中大量的示例是其他開(kāi)發(fā)者了解框架、入手框架的極佳參考。

發(fā)布到 nuget

們開(kāi)發(fā)了一個(gè)支持模塊化和自動(dòng)服務(wù)注冊(cè)的框架，通過(guò) Maomi.Core 實(shí)現(xiàn)模塊化應(yīng)用的開(kāi)發(fā)。

完成代碼后，我們需要將代碼共享給其他人，那么可以使用 nuget 包的方式。

當(dāng)類(lèi)庫(kù)開(kāi)發(fā)完成后，我們可以打包成 nuget 文件，上傳這個(gè)到 nuget.org ，或者是內(nèi)部的私有倉(cāng)庫(kù)，供其他開(kāi)發(fā)者使用。

在 Maomi.Core.csproj 項(xiàng)目的的 PropertyGroup 屬性中加上以下配置，以便能夠在發(fā)布類(lèi)庫(kù)時(shí)，生成 nuget 包。

		true
		1.0.0
		
		True

或者右鍵點(diǎn)擊項(xiàng)目-屬性-打包。

當(dāng)然，你也可以在 Visual Studio 中點(diǎn)擊項(xiàng)目右鍵屬性，在面板中進(jìn)行可視化配置。

你可以配置項(xiàng)目的 github 地址、發(fā)布說(shuō)明、開(kāi)源許可證等。

配置完成后，可以使用 Visual Studio 發(fā)布項(xiàng)目，或使用 dotnet publish -c Release 命令發(fā)布項(xiàng)目。

發(fā)布項(xiàng)目后，可以在輸出目錄找到 .nupkg 文件。