C#反射与特性(六)：设计一个仿ASP.NETCore
从前面第四篇开始，进入了实践练习；第五篇实现了实例化一个类型以及对成员方法等的调用。当然，还有一些操作尚将在后面的章节进行介绍。
因为本系列属于实践练习，所以系列文章可能比较多，内容比较长。要学会一种技术，最好的方法是跟着例子代码写一次，运行调试。
本篇文章属于阶段练习，将前面学习到的所有知识点进行总结，实现一个依赖注入功能，仿照 ASP.NET Core 访问 API，自动传递参数以及执行方法，最后返回结果。
效果：
对用户效果
- 用户能够访问 Controller
- 用户能够访问 Action
- 访问 Action 时，传递参数
程序要求效果
- 实例化类型
- 识别类型构造函数类型
- 根据构造函数类型动态实例化类型并且注入
- 动态调用合适的重载方法
1，编写依赖注入框架
写完后的代码大概是这样的
笔者直接在 Program 类里面写了，代码量为 200 行左右（包括详细注释、空白隔行）。
开始编写代码前，请先引入以下命名空间：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
在 Program 中，增加以下代码
private static Assembly assembly = Assembly.GetCallingAssembly();
private static Type[] types;
static Program()
{
types = assembly.GetTypes();
}
上面代码的作用是，获取到当前程序的程序集，并且获取元数据信息。
这是反射第一步。
1.1 路由索引
ASP.NET Core 中的路由规则十分丰富，我们自定义各种 URL 规则。主要原理是程序在运行时，将 Controller 、Action 的 [route] 等特性收集起来，生成路由表。
程序执行的基础是类型、方法，ASP.NET Core 中的 Controller 即是 Class，Action 即 Method。
从前面的学习中，我们了解到，通过反射实例化和调用一个类型的成员，只需要确定类型名称、方法名称即可。
对于路由表，我们可以假设(不是指ASP.NET Core的原理)用户访问 URL 时，先从路由表中对比，如果有结果，则将对应的 Class 、Method 拿到手，通过反射机制调用实例化类型调用函数。
这里不实现这么复杂的结构，只实现 Controller-Action 层次的路由。
1.1.1 判断控制器 Controller 是否存在
Program 中，添加一个方法，用于判断当前程序集中是否存在此控制器。
/// <summary>
/// 判断是否有此控制器，并且返回 Type
/// </summary>
/// <param name="controllerName">控制器名称(不带Controller)</param>
/// <returns></returns>
private static (bool, Type) IsHasController(string controllerName)
{
// 不分大小写
string name = controllerName + "Controller";
if (!types.Any(x => x.Name.ToLower() == name.ToLower()))
return (false, null);
return (true, types.FirstOrDefault(x => x.Name.ToLower() == name.ToLower()));
}
代码非常简单，而且有 Linq 的加持，几行代码就 OK。
实现原理：
判断程序集中是否具有 {var}Controller 命名的类型，例如 HomeController。
如果存在，则获取此控制器的 Type 。
1.1.2 判断 Action 是否存在
Action 是在 Controller 里面的(方法在类型里面)，所以我们这里只需要判断以下就行。
/// <summary>
/// 判断一个控制器中是否具有此方法
/// </summary>
/// <param name="type">控制器类型</param>
/// <param name="actionName">Action名称</param>
/// <returns></returns>
private static bool IsHasAction(Type type, string actionName)
{
// 不分大小写
return type.GetMethods().Any(x => x.Name.ToLower() == actionName.ToLower());
}
实现原理：
判断一个类型中，是否存在 {actionname} 这个方法。
这里不返回 MethodInfo，而是返回 bool ，是因为考虑到，方法是可以重载的，我们要根据请求时的参数，确定使用哪个方法。
所以这里只做判断，获取 MethodInfo 的过程在后面。
1.2 依赖实例化
意思是，获取一个类型的构造函数中，所有参数信息，并且为每一个类型实现自动创建实例。
传入参数：
需要进行依赖注入的类型的 Type。
返回数据：
构造函数参数的实例对象列表(反射都是object)。
/// <summary>
/// 实例化依赖
/// </summary>
/// <param name="type">要被实例化依赖注入的类型</param>
public static object[] CreateType(Type type)
{
// 这里只使用一个构造函数
ConstructorInfo construct = type.GetConstructors().FirstOrDefault();
// 获取类型的构造函数参数
ParameterInfo[] paramList = construct.GetParameters();
// 依赖注入的对象列表
List<object> objectList = new List<object>();
// 为构造函数的每个参数类型，实例化一个类型
foreach (ParameterInfo item in paramList)
{
//获取参数类型：item.ParameterType.Name
// 获取程序中，哪个类型实现了 item 的接口
Type who = types.FirstOrDefault(x => x.GetInterfaces().Any(z => z.Name == item.ParameterType.Name));
// 实例化
object create = Activator.CreateInstance(who, new object[] { });
objectList.Add(create);
}
return objectList.ToArray();
}
这里有两个点：
① 对于一个类型来说，可能有多个构造函数；
② 使用 ASP.NET Core 编写一个控制器时，估计没谁会写两个构造函数吧。。。
基于以上两点，我们只要一个构造函数就行，不需要考虑很多情况，我们默认：一个控制器只允许定义一个构造函数，不能定义多个构造函数。
过程实现原理：
获取到构造函数后，接着获取构造函数中的参数列表(ParameterInfo[])。
这里又有几个问题
参数是接口类型
参数是抽象类型
- 参数是正常的 Class 类型
那么，按照以上划分，要考虑的情况更加多了。这里我们根据依赖倒置原则，我们约定，构造函数中的类型，只允许是接口。
因为这里没有 IOC 容器，只是简单的反射实现，所以我们不需要考虑那么多情况（200行代码还想怎么样。。。）。
后面我们查找有哪个类型实现了此接口，就把这个类型实例化做参数传递进去。
注：后面会持续推出更多实战型教程，敬请期待；可以关注微信订阅号 《NCC 开源社区》，获取最新资讯。
1.3 实例化类型、依赖注入、调用方法
目前来到了依赖注入的最后阶段，实例化一个类型、注入依赖、调用方法。
/// <summary>
/// 实现依赖注入、调用方法
/// </summary>
/// <param name="type">类型</param>
/// <param name="actionName">方法名称</param>
/// <param name="paramList">调用方法的参数列表</param>
/// <returns></returns>
private static object StartASPNETCORE(Type type, string actionName, params object[] paramList)
{
// 获取 Action 重载方法
// 名字一样，参数个数一致
MethodInfo method = type.GetMethods()
.FirstOrDefault(x => x.Name.ToLower() == actionName.ToLower()
&& x.GetParameters().Length == paramList.Length);
// 参数有问题，找不到合适的 Action 重载进行调用
// 报 405
if (method == null)
return "405";
// 实例化控制器
// 获取依赖对象
object[] inject = CreateType(type);
// 注入依赖，实例化对象
object example = Activator.CreateInstance(type, inject);
// 执行方法并且返回执行结果
object result;
try
{
result = method.Invoke(example, paramList);
return result;
}
catch
{
// 报 500
result = "500";
return result;
}
}
实现原理：
通过 CreateType 方法，已经拿到实例化类型的构造函数的参数对象了。
这里确定调用哪个重载方法的方式，是通过参数的多少，因为这里控制台输入只能获取 string，更加复杂通过参数类型获取重载方法，可以自行另外测试。
调用一个方法大概以下几个步骤（不分顺序）：
获取类型实例；
获取类型 Type；
获取方法 MethodInfo；
方法的参数对象；
// 获取依赖对象
object[] inject = CreateType(type);
// 注入依赖，实例化对象
object example = Activator.CreateInstance(type, inject);
上面代码中，就是实现非常简单的依赖注入过程。
剩下的就是调用方法，通过参数多少去调用相应的重载方法了。
2，编写控制器和参数类型
2.1 编写类型
编写一个接口
/// <summary>
/// 接口
/// </summary>
public interface ITest
{
string Add(string a, string b);
}
实现接口
/// <summary>
/// 实现
/// </summary>
public class Test : ITest
{
public string Add(string a, string b)
{
Console.WriteLine("Add方法被执行");
return a + b;
}
}
2.2 实现控制器
我们按照 ASP.NET Core 写一个控制器的大概形式，实现一个低仿的山寨控制器。
/// <summary>
/// 需要自动实例化并且进行依赖注入的类
/// </summary>
public class MyClassController
{
private ITest _test;
public MyClassController(ITest test)
{
_test = test;
}
/// <summary>
/// 这是一个 Action
/// </summary>
/// <returns></returns>
public string Action(string a, string b)
{
// 校验http请求的参数
if (string.IsNullOrEmpty(a) || string.IsNullOrEmpty(b))
return "验证不通过";
//开始运行
var result = _test.Add(a, b);
Console.WriteLine("NCC社区", "牛逼");
// 响应结果
return result;
}
}
这是常见的依赖注入使用场景：
private ITest _test;
public MyClassController(ITest test)
{
_test = test;
}
可以是一个数据库上下文，可以各种类型。
由于控制台输入获取到的是 string，为了减少麻烦，里面只使用的 Action 方法，参数类型都是 string。
3，实现低配山寨 ASP.NET Core
好吧，我承认我这跟ASP.NET Core没关系，这个这是一个非常简单的功能。
主要就是仿照 StartUp ，实现请求流程和数据返回。
static void Main(string[] args)
{
while (true)
{
string read = string.Empty;
Console.WriteLine("用户你好，你要访问的控制器(不需要带Controller)");
read = Console.ReadLine();
// 检查是否具有此控制器并且获取 Type
var hasController = IsHasController(read);
// 找不到控制器，报 404 ，让用户重新请求
if (!hasController.Item1)
{
Console.WriteLine("404");
continue;
}
Console.WriteLine("控制器存在，请接着输入要访问的 Action");
read = Console.ReadLine();
// 检查是否具有此 Action 并且获取 Type
bool hasAction = IsHasAction(hasController.Item2, read);
// 找不到，继续报 404
if (hasAction == false)
{
Console.WriteLine("404");
continue;
}
// 目前为止，URL存在，那么就是传递参数了
Console.WriteLine("用户你好，URL 存在，请输入参数");
Console.WriteLine("输入每个参数按一下回车键，结束输入请输入0再按下回车键");
// 开始接收用户输入的参数
List<object> paramList = new List<object>();
while (true)
{
string param = Console.ReadLine();
if (param == "0")
break;
paramList.Add(param);
}
Console.WriteLine("输入结束，正在发送 http 请求 \n");
// 用户的请求已经校验通过并且开始，现在来继续仿 ASP.NET Core 执行
object response = StartASPNETCORE(hasController.Item2, read, paramList.ToArray());
Console.WriteLine("执行结果是：");
Console.WriteLine(response);
Console.ReadKey();
}
实现过程和原理：
- 判断 URL 是否存在（路由）
- 接收用户输入的参数
- 依赖注入实现
- 调用方法，传输参数，返回实现结果