生成模塊依賴樹如圖所示：

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

偽代碼示例如下：

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

實現(xiàn)模塊化和自動服務(wù)注冊

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

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

接下來，我們思考模塊化框架需要解決哪些問題或支持哪些功能：

• 如何識別和注冊服務(wù)；

• 框架能夠識別模塊的依賴，生成模塊依賴樹，能夠檢測到循環(huán)依賴等問題；

• 多個模塊可能引用了同一個模塊 A，但是模塊 A 只能被實例化一次；

• 初始化模塊的順序；

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

我們先解決第一個問題，

因為自動服務(wù)注冊是根據(jù)模塊所在的程序集掃描標記類，識別所有使用了 InjectOnAttribute 特性的類型，所以我們可以先編寫一個程序集掃描方法，該方法的功能是通過程序集掃描所有類型，然后根據(jù)特性配置注冊服務(wù)。

/// 

/// 自動依賴注入
/// 
/// 
/// 
/// 已被注入的服務(wù)
private static void InitInjectService(IServiceCollection services, Assembly assembly, HashSet injectTypes)
{
	// 只掃描可實例化的類，不掃描靜態(tà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;
			}
		}

		// 注入父類
		if (inject.Scheme == InjectScheme.OnlyBaseClass || inject.Scheme == InjectScheme.Any)
		{
			var baseType = item.BaseType;
			if (baseType == null) throw new ArgumentException($"{item.Name} 注入模式 {nameof(inject.Scheme)} 未找到父類！");
			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;
			}
		}
	}
}

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

		/// 

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


		/// 

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

			IServiceProvider scope = BuildModule(services, startupModule);
		}

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

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

		/// 

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

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

			// 構(gòu)建模塊依賴樹
			BuildTree(services, rootTree, rootDependencies);

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

			// 初始化所有模塊類
			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();

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

			return scope;
		}

第一步，構(gòu)建模塊依賴樹。

		/// 

		/// 構(gòu)建模塊依賴樹
		/// 
		/// 
		/// 
		/// 其依賴的模塊
		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)依賴檢測
				// 檢查當前模塊(parentTree)依賴的模塊(childTree)是否在之前出現(xiàn)過，如果是，則說明是循環(huán)依賴
				var isLoop = currentNode.ContainsTree(childTree);
				if (isLoop)
				{
					throw new OverflowException($"檢測到循環(huán)依賴引用或重復(fù)引用！{currentNode.ModuleType.Name} 依賴的 {childModule.ModuleType.Name} 模塊在其父模塊中出現(xiàn)過！");
				}

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

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

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

		/// 

		/// 從模塊樹中遍歷
		/// 
		/// 
		/// 
		/// 已經(jīng)被注冊到容器中的模塊類
		/// 模塊類所在的程序集'
		/// 已被注冊到容器的服務(wù)
		/// 模塊節(jié)點
		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);
				}
			}

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

				// 實例化此模塊
				// 掃描此模塊（程序集）中需要依賴注入的服務(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)講解完畢，通過本章的實踐，我們擁有了一個具有模塊化和自動服務(wù)注冊的框架。可是，別高興得太早，我們應(yīng)當如何驗證框架是可靠的呢？答案是單元測試。在完成 Maomi.Core 項目之后，筆者立即編寫了 Maomi.Core.Tests 單元測試項目，只有當單元測試全部通過之后，筆者才能自信地把代碼放到書中。為項目編寫單元測試是一個好習(xí)慣，尤其是對框架類的項目，我們需要編寫大量的單元測試驗證框架的可靠性，同時單元測試中大量的示例是其他開發(fā)者了解框架、入手框架的極佳參考。

發(fā)布到 nuget

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

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

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

在 Maomi.Core.csproj 項目的的 PropertyGroup 屬性中加上以下配置，以便能夠在發(fā)布類庫時，生成 nuget 包。

		true
		1.0.0
		
		True

或者右鍵點擊項目-屬性-打包。

當然，你也可以在 Visual Studio 中點擊項目右鍵屬性，在面板中進行可視化配置。

你可以配置項目的 github 地址、發(fā)布說明、開源許可證等。

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

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