目录
【微信平台,此文仅授权《NCC 开源社区》订阅号发布】
从前面第四篇开始,进入了实践练习;第五篇实现了实例化一个类型以及对成员方法等的调用。当然,还有一些操作尚将在后面的章节进行介绍。
因为本系列属于实践练习,所以系列文章可能比较多,内容比较长。要学会一种技术,最好的方法是跟着例子代码写一次,运行调试。
本篇文章属于阶段练习,将前面学习到的所有知识点进行总结,实现一个依赖注入功能,仿照 ASP.NET Core 访问 API,自动传递参数以及执行方法,最后返回结果。
本章的代码已上传至 https://gitee.com/whuanle/codes/pby1q6amnzosgkxw830c470
效果:
对用户效果
- 用户能够访问 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 是否存在(路由)
- 接收用户输入的参数
- 依赖注入实现
- 调用方法,传输参数,返回实现结果