生成模块依赖树如图所示：

首先从 E ₀ 开始扫描，因为 E ₀ 下存在子节点 C ₀ 、 D ₀ ，那么就会先顺着 C ₀ 再次扫描，扫描到 A ₀ 时，因为 A ₀ 下已经没有子节点了，所以会对 A ₀ 对应的模块 A 进行初始化。根据上图模块依赖树进行后序遍历，初始化模块的顺序是（已经被初始化的模块会跳过）：

伪代码示例如下：

		private static void InitModuleTree(ModuleNode moduleNode)
		{
			if (moduleNode.Childs != null)
			{
				foreach (var item in moduleNode.Childs)
				{
					InitModuleTree(item);
				}
			}
            
            // 如果该节点已经没有子节点
			// 如果模块没有处理过
			if (!moduleTypes.Contains(moduleNode.ModuleType))
			{
				InitInjectService(moduleNode.ModuleType);
			}
		}

实现模块化和自动服务注册

本小节的代码都在 ModuleExtensions.cs 中。

当我们把接口、枚举、特性等类型定义之后，接下来我们便要思考如何实例化模块、检测模块的依赖关系，实现自动服务注册。为了简化设计，我们可以将模块化自动服务注册写在一起，当初始化一个模块时，框架同时会扫描该程序集中的服务进行注册。如果程序集中不包含模块类，那么框架不会扫描该程序集，也就不会注册服务。

接下来，我们思考模块化框架需要解决哪些问题或支持哪些功能：

• 如何识别和注册服务；

• 框架能够识别模块的依赖，生成模块依赖树，能够检测到循环依赖等问题；

• 多个模块可能引用了同一个模块 A，但是模块 A 只能被实例化一次；

• 初始化模块的顺序；

• 模块类本身要作为服务注册到容器中，实例化模块类时，需要支持依赖注入，也就是说模块类的构造函数可以注入其它服务；

我们先解决第一个问题，

因为自动服务注册是根据模块所在的程序集扫描标记类，识别所有使用了 InjectOnAttribute 特性的类型，所以我们可以先编写一个程序集扫描方法，该方法的功能是通过程序集扫描所有类型，然后根据特性配置注册服务。

/// 

/// 自动依赖注入
/// 
/// 
/// 
/// 已被注入的服务
private static void InitInjectService(IServiceCollection services, Assembly assembly, HashSet injectTypes)
{
	// 只扫描可实例化的类，不扫描静态类、接口、抽象类、嵌套类、非公开类等
	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)} 未找到服务！");
			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;
			}
		}
	}
}

定义两个扩展函数，用于注入入口模块。

		/// 

		/// 注册模块化服务
		/// 
		/// 入口模块
		/// 
		public static void AddModule(this IServiceCollection services)
			where TModule : IModule
		{
			AddModule(services, typeof(TModule));
		}


		/// 

		/// 注册模块化服务
		/// 
		/// 
		/// 入口模块
		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);
		}

框架需要从入口模块程序集开始查找被依赖的模块程序集，然后通过后序遍历初始化每个模块，并扫描该模块程序集中的服务。

创建一个 BuildModule 函数，BuildModule 为构建模块依赖树、初始化模块提前创建环境。

		/// 

		/// 构建模块依赖树并初始化模块
		/// 
		/// 
		/// 
		/// 
		/// 
		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();

			// 构建模块依赖树
			BuildTree(services, rootTree, rootDependencies);

			// 构建一个 Ioc 实例，以便初始化模块类
			var scope = services.BuildServiceProvider();

			// 初始化所有模块类
			var serviceContext = new ServiceContext(services, scope.GetService()!);

			// 记录已经处理的程序集、模块和服务，以免重复处理
			HashSet moduleAssemblies = new HashSet { startupModule.Assembly };
			HashSet moduleTypes = new HashSet();
			HashSet injectTypes = new HashSet();

            // 后序遍历树并初始化每个模块
			InitModuleTree(scope, serviceContext, moduleAssemblies, moduleTypes, injectTypes, rootTree);

			return scope;
		}

第一步，构建模块依赖树。

		/// 

		/// 构建模块依赖树
		/// 
		/// 
		/// 
		/// 其依赖的模块
		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
				};

				// 循环依赖检测
				// 检查当前模块(parentTree)依赖的模块(childTree)是否在之前出现过，如果是，则说明是循环依赖
				var isLoop = currentNode.ContainsTree(childTree);
				if (isLoop)
				{
					throw new OverflowException($"检测到循环依赖引用或重复引用！{currentNode.ModuleType.Name} 依赖的 {childModule.ModuleType.Name} 模块在其父模块中出现过！");
				}

				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);
			}
		}

通过后序遍历识别依赖时，由于一个模块可能会出现多次，所以初始化时需要判断模块是否已经初始化，然后对模块进行初始化并扫描模块程序集中所有的类型，进行服务注册。

		/// 

		/// 从模块树中遍历
		/// 
		/// 
		/// 
		/// 已经被注册到容器中的模块类
		/// 模块类所在的程序集'
		/// 已被注册到容器的服务
		/// 模块节点
		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);

				// 实例化此模块
				// 扫描此模块（程序集）中需要依赖注入的服务
				var module = (IModule)serviceProvider.GetRequiredService(moduleNode.ModuleType);
				module.ConfigureServices(context);
				InitInjectService(context.Services, moduleNode.ModuleType.Assembly, injectTypes);
				moduleAssemblies.Add(moduleNode.ModuleType.Assembly);
			}
		}

至此，Maomi.Core 所有的代码都已经讲解完毕，通过本章的实践，我们拥有了一个具有模块化和自动服务注册的框架。可是，别高兴得太早，我们应当如何验证框架是可靠的呢？答案是单元测试。在完成 Maomi.Core 项目之后，笔者立即编写了 Maomi.Core.Tests 单元测试项目，只有当单元测试全部通过之后，笔者才能自信地把代码放到书中。为项目编写单元测试是一个好习惯，尤其是对框架类的项目，我们需要编写大量的单元测试验证框架的可靠性，同时单元测试中大量的示例是其他开发者了解框架、入手框架的极佳参考。

发布到 nuget

们开发了一个支持模块化和自动服务注册的框架，通过 Maomi.Core 实现模块化应用的开发。

完成代码后，我们需要将代码共享给其他人，那么可以使用 nuget 包的方式。

当类库开发完成后，我们可以打包成 nuget 文件，上传这个到 nuget.org ，或者是内部的私有仓库，供其他开发者使用。

在 Maomi.Core.csproj 项目的的 PropertyGroup 属性中加上以下配置，以便能够在发布类库时，生成 nuget 包。

		true
		1.0.0
		
		True

或者右键点击项目-属性-打包。

当然，你也可以在 Visual Studio 中点击项目右键属性，在面板中进行可视化配置。

你可以配置项目的 github 地址、发布说明、开源许可证等。

配置完成后，可以使用 Visual Studio 发布项目，或使用 dotnet publish -c Release 命令发布项目。

发布项目后，可以在输出目录找到 .nupkg 文件。