当前位置:Gxlcms > asp.net > 解读ASP.NET 5 & MVC6系列教程(12):基于Lamda表达式的强类型Routing实现

解读ASP.NET 5 & MVC6系列教程(12):基于Lamda表达式的强类型Routing实现

时间:2021-07-01 10:21:17 帮助过:15人阅读

前面的深入理解Routing章节,我们讲到了在MVC中,除了使用默认的ASP.NET 5的路由注册方式,还可以使用基于Attribute的特性(Route和HttpXXX系列方法)来定义。本章,我们将讲述一种基于Lambda表达式的强类型类型。

这种方式的基本使用示例如下:

  1. services.Configure<MvcOptions>(opt =>
  2. {
  3. opt.EnableTypedRouting();
  4. opt.GetRoute("homepage", c => c.Action<ProductsController>(x => x.Index()));
  5. opt.GetRoute("aboutpage/{name}", c => c.Action<ProductsController>(x => x.About(Param<string>.Any)));
  6. opt.PostRoute("sendcontact", c => c.Action<ProductsController>(x => x.Contact()));
  7. });

从示例中可以看出,我们可以通过GetRoute或PostRoute等扩展方法来定义route,而且后面使用Lambda表达式来定Controller的类型和Action的方法。

注意,在这里获取Action的方法名,是通过委托执行该Action方法来实现的(实际上并没有执行,而是基于此获取该Action的MethodInfo)。

实现原理

Stratup.csConfigureServices方法中配置services的时候,我们可以对MVC站点使用的核心配置文件MvcOptions进行配置,其中该类有一个ApplicationModelConventions属性(List<IApplicationModelConvention>)可以保存一个IApplicationModelConvention接口的集合,改接口可以对MVC程序的程序模型进行管线处理,该接口的定义如下:

  1. public interface IApplicationModelConvention
  2. {
  3. void Apply(ApplicationModel application);
  4. }

接口中的Apply方法所接收的参数类型是ApplicationModel,而ApplicationModel有两个极其重要的内容可以供我们操作,一个是Controller模型集合,一个是各种Filter的集合,该类的定义如下:

  1. public class ApplicationModel
  2. {
  3. public ApplicationModel();
  4. public IList<ControllerModel> Controllers { get; }
  5. public IList<IFilter> Filters { get; }
  6. }

这里最重要的就是ControllerModel类,该类的实例上保存了各种各样重要而又可以操作的信息,比如该类和相关Action上的路由定义数据,API描述信息,路由约束等等,这些信息都可以进行操作。

新的IApplicationModelConvention注册方式如下:

  1. services.Configure<MvcOptions>(opt =>
  2. {
  3. opts.ApplicationModelConventions.Add(new MyApplicationModelConvention());
  4. });

所以我们可以利用这个方法,在合适的时机对整个MVC的程序模型做响应的调整和修改,本章节中的强类型路由就是利用这个特性来实现的。

实现步骤

首先定义一个强类型的路由模型TypedRouteModel类,该类要继承于AttributeRouteModelAttributeRouteModel类是基于Attribute路由的基本模型,TypedRouteModel类的代码如下:

  1. public class TypedRouteModel : AttributeRouteModel
  2. {
  3. public TypedRouteModel(string template)
  4. {
  5. Template = template;
  6. HttpMethods = new string[0];
  7. }
  8. public TypeInfo ControllerType { get; private set; }
  9. public MethodInfo ActionMember { get; private set; }
  10. public IEnumerable<string> HttpMethods { get; private set; }
  11. public TypedRouteModel Controller<TController>()
  12. {
  13. ControllerType = typeof(TController).GetTypeInfo();
  14. return this;
  15. }
  16. public TypedRouteModel Action<T, U>(Expression<Func<T, U>> expression)
  17. {
  18. ActionMember = GetMethodInfoInternal(expression);
  19. ControllerType = ActionMember.DeclaringType.GetTypeInfo();
  20. return this;
  21. }
  22. public TypedRouteModel Action<T>(Expression<Action<T>> expression)
  23. {
  24. ActionMember = GetMethodInfoInternal(expression);
  25. ControllerType = ActionMember.DeclaringType.GetTypeInfo();
  26. return this;
  27. }
  28. private static MethodInfo GetMethodInfoInternal(dynamic expression)
  29. {
  30. var method = expression.Body as MethodCallExpression;
  31. if (method != null)
  32. return method.Method;
  33. throw new ArgumentException("Expression is incorrect!");
  34. }
  35. public TypedRouteModel WithName(string name)
  36. {
  37. Name = name;
  38. return this;
  39. }
  40. public TypedRouteModel ForHttpMethods(params string[] methods)
  41. {
  42. HttpMethods = methods;
  43. return this;
  44. }
  45. }

该类主要的功能是:定义支持传入Controller类型,支持链式调用。

然后再定义一个继承IApplicationModelConvention接口的TypedRoutingApplicationModelConvention类。代码如下:

  1. public class TypedRoutingApplicationModelConvention : IApplicationModelConvention
  2. {
  3. internal static readonly Dictionary<TypeInfo, List<TypedRouteModel>> Routes = new Dictionary<TypeInfo, List<TypedRouteModel>>();
  4. public void Apply(ApplicationModel application)
  5. {
  6. foreach (var controller in application.Controllers)
  7. {
  8. if (Routes.ContainsKey(controller.ControllerType))
  9. {
  10. var typedRoutes = Routes[controller.ControllerType];
  11. foreach (var route in typedRoutes)
  12. {
  13. var action = controller.Actions.FirstOrDefault(x => x.ActionMethod == route.ActionMember);
  14. if (action != null)
  15. {
  16. action.AttributeRouteModel = route;
  17. //注意这里是直接替换,会影响现有Controller上的Route特性定义的路由
  18. foreach (var method in route.HttpMethods)
  19. {
  20. action.HttpMethods.Add(method);
  21. }
  22. }
  23. }
  24. }
  25. }
  26. }
  27. }

在该类中,保存了一个静态变量Routes,用于保存所有以Lamda表达式方式声明的路由,然后在现有的Controllers集合中进行查找及修改,然后替换AttributeRouteModel属性,并设置响应的Http Method(如果不设置,则默认所有的方式都允许)。

在这里,我们只是简单替换action.AttributeRouteModel,所以会导致一些缺陷(比如一个Action只能支持一个路由路径,以最后一个为准),各位同学可以根据自己的能力进行优化。

优化的时候,要注意Controller上的Route集合保存在controller.Attributes属性上,Action上的Route集合保存在action.Attributes属性上,可以对其进行优化。

然后,在MvcOptions上,我们再为TypeRouteModel添加一些扩展方法以方便使用,代码如下:

  1. public static class MvcOptionsExtensions
  2. {
  3. public static TypedRouteModel GetRoute(this MvcOptions opts, string template, Action<TypedRouteModel> configSetup)
  4. {
  5. return AddRoute(template, configSetup).ForHttpMethods("GET");
  6. }
  7. public static TypedRouteModel PostRoute(this MvcOptions opts, string template, Action<TypedRouteModel> configSetup)
  8. {
  9. return AddRoute(template, configSetup).ForHttpMethods("POST");
  10. }
  11. public static TypedRouteModel PutRoute(this MvcOptions opts, string template, Action<TypedRouteModel> configSetup)
  12. {
  13. return AddRoute(template, configSetup).ForHttpMethods("PUT");
  14. }
  15. public static TypedRouteModel DeleteRoute(this MvcOptions opts, string template, Action<TypedRouteModel> configSetup)
  16. {
  17. return AddRoute(template, configSetup).ForHttpMethods("DELETE");
  18. }
  19. public static TypedRouteModel TypedRoute(this MvcOptions opts, string template, Action<TypedRouteModel> configSetup)
  20. {
  21. return AddRoute(template, configSetup);
  22. }
  23. private static TypedRouteModel AddRoute(string template, Action<TypedRouteModel> configSetup)
  24. {
  25. var route = new TypedRouteModel(template);
  26. configSetup(route);
  27. if (TypedRoutingApplicationModelConvention.Routes.ContainsKey(route.ControllerType))
  28. {
  29. var controllerActions = TypedRoutingApplicationModelConvention.Routes[route.ControllerType];
  30. controllerActions.Add(route);
  31. }
  32. else
  33. {
  34. var controllerActions = new List<TypedRouteModel> { route };
  35. TypedRoutingApplicationModelConvention.Routes.Add(route.ControllerType, controllerActions);
  36. }
  37. return route;
  38. }
  39. public static void EnableTypedRouting(this MvcOptions opts)
  40. {
  41. opts.ApplicationModelConventions.Add(new TypedRoutingApplicationModelConvention());
  42. }
  43. }

在上述代码中,我们添加了一个EnableTypedRouting扩展方法,以便向MvcOptions.ApplicationModelConventions属性上添加新的TypedRoutingApplicationModelConvention类型示例。

其它的扩展方法则都是用于声明相关的route,大家注意,在最开头的示例中,我们看到获取action信息的方法是通过委托调用该action方法(但没有真正调用),但是有的方法有参数,那怎么办呢?为此,我们定于一个忽略参数的Param类,代码如下:

  1. public static class Param<TValue>
  2. {
  3. public static TValue Any
  4. {
  5. get { return default(TValue); }
  6. }
  7. }

这样,我们为含有参数的About方法定于路由的时候,就可以这样来定义了,代码如下:

  1. opt.GetRoute("aboutpage/{name}", c => c.Action<HomeController>(x => x.About(Param<string>.Any)));

另外,由于TypeRouteModel里很多方法都是可以链式调用,所以我们也可以通过这种方式为route指定一个名称,示例代码如下:

  1. opt.GetRoute("homepage", c => c.Action<HomeController>(x => x.Index())).WithName("foo");

至此,整个强类型路由的功能就实现完毕了,大家在使用的时候,就多了一种选择了。

弊端(或Bug)

我们看到,在上面实现IApplicationModelConvention接口的时候,我们只是简单的对action.AttributeRouteModel进行替换,也就是说,如果你在Action上已经了Route特性的话,他会把你的信息给你覆盖掉,从而导致你的route失效。比如,如果你定义了一个这样的自定义路由:

  1. public class ProductsController : Controller
  2. {
  3. [Route("index")]
  4. public IActionResult Index()
  5. {
  6. return Content("Index");
  7. }
  8. }

然后又通过Lamda表达式又定义了强类型路由,代码如下:

  1. opt.GetRoute("homepage", c => c.Action<ProductsController>(x => x.Index()));

那么,你只能通过/homepage开来访问,而不能通过/index来访问了,因为它把你的Route给你覆盖掉了。

但是,上述Lamda表达式方式并没有覆盖Controller上定义的Route特性定义,所以如果你在ProductsController上定义了Route特性的话,两者就会组合在一起,例如:

  1. [Route("products")]
  2. public class ProductsController : Controller
  3. {
  4. public IActionResult Index()
  5. {
  6. return Content("Index");
  7. }
  8. }

那么你的访问网址应该是/products/homepage,而不是/homepage。不过如果你在Lamda表达式方式里的代码,是如下这样的话:

  1. opt.GetRoute("/homepage", c => c.Action<ProductsController>(x => x.Index()));

那你的访问网址就应该是/homepage了,因为该路由字符是绝对路径/homepage,而不是homepage

参考:http://www.strathweb.com/2015/03/strongly-typed-routing-asp-net-mvc-6-iapplicationmodelconvention/

人气教程排行