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

前面的深入理解routing章节，我们讲到了在mvc中，除了使用默认的asp.net 5的路由注册方式，还可以使用基于attribute的特性（route和httpxxx系列方法）来定义。本章，我们将讲述一种基于lambda表达式的强类型类型。

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

services.configure<mvcoptions>(opt =>
{
 opt.enabletypedrouting();

 opt.getroute("homepage", c => c.action<productscontroller>(x => x.index()));
 opt.getroute("aboutpage/{name}", c => c.action<productscontroller>(x => x.about(param<string>.any)));
 opt.postroute("sendcontact", c => c.action<productscontroller>(x => x.contact()));
});

从示例中可以看出，我们可以通过getroute或postroute等扩展方法来定义route，而且后面使用lambda表达式来定controller的类型和action的方法。

注意，在这里获取action的方法名，是通过委托执行该action方法来实现的（实际上并没有执行，而是基于此获取该action的methodinfo）。

实现原理

在stratup.cs的configureservices方法中配置services的时候，我们可以对mvc站点使用的核心配置文件mvcoptions进行配置，其中该类有一个applicationmodelconventions属性（list<iapplicationmodelconvention>）可以保存一个iapplicationmodelconvention接口的集合，改接口可以对mvc程序的程序模型进行管线处理，该接口的定义如下：

public interface iapplicationmodelconvention
{
 void apply(applicationmodel application);
}

接口中的apply方法所接收的参数类型是applicationmodel，而applicationmodel有两个极其重要的内容可以供我们操作，一个是controller模型集合，一个是各种filter的集合，该类的定义如下：

public class applicationmodel
{
 public applicationmodel();

 public ilist<controllermodel> controllers { get; }
 public ilist<ifilter> filters { get; }
}

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

新的iapplicationmodelconvention注册方式如下：

services.configure<mvcoptions>(opt =>
{
 opts.applicationmodelconventions.add(new myapplicationmodelconvention());
});

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

实现步骤

首先定义一个强类型的路由模型typedroutemodel类，该类要继承于attributeroutemodel，attributeroutemodel类是基于attribute路由的基本模型，typedroutemodel类的代码如下：

public class typedroutemodel : attributeroutemodel
{
 public typedroutemodel(string template)
 {
  template = template;
  httpmethods = new string[0];
 }

 public typeinfo controllertype { get; private set; }

 public methodinfo actionmember { get; private set; }

 public ienumerable<string> httpmethods { get; private set; }

 public typedroutemodel controller<tcontroller>()
 {
  controllertype = typeof(tcontroller).gettypeinfo();
  return this;
 }

 public typedroutemodel action<t, u>(expression<func<t, u>> expression)
 {
  actionmember = getmethodinfointernal(expression);
  controllertype = actionmember.declaringtype.gettypeinfo();
  return this;
 }

 public typedroutemodel action<t>(expression<action<t>> expression)
 {
  actionmember = getmethodinfointernal(expression);
  controllertype = actionmember.declaringtype.gettypeinfo();
  return this;
 }

 private static methodinfo getmethodinfointernal(dynamic expression)
 {
  var method = expression.body as methodcallexpression;
  if (method != null)
   return method.method;

  throw new argumentexception("expression is incorrect!");
 }

 public typedroutemodel withname(string name)
 {
  name = name;
  return this;
 }

 public typedroutemodel forhttpmethods(params string[] methods)
 {
  httpmethods = methods;
  return this;
 }
}

该类主要的功能是：定义支持传入controller类型，支持链式调用。

然后再定义一个继承iapplicationmodelconvention接口的typedroutingapplicationmodelconvention类。代码如下：

public class typedroutingapplicationmodelconvention : iapplicationmodelconvention
{
 internal static readonly dictionary<typeinfo, list<typedroutemodel>> routes = new dictionary<typeinfo, list<typedroutemodel>>();

 public void apply(applicationmodel application)
 {
  foreach (var controller in application.controllers)
  {
   if (routes.containskey(controller.controllertype))
   {
    var typedroutes = routes[controller.controllertype];
    foreach (var route in typedroutes)
    {
     var action = controller.actions.firstordefault(x => x.actionmethod == route.actionmember);
     if (action != null)
     {
      action.attributeroutemodel = route;
      //注意这里是直接替换，会影响现有controller上的route特性定义的路由
      foreach (var method in route.httpmethods)
      {
       action.httpmethods.add(method);
      }
     }
    }
   }
  }
 }
}

在该类中，保存了一个静态变量routes，用于保存所有以lamda表达式方式声明的路由，然后在现有的controllers集合中进行查找及修改，然后替换attributeroutemodel属性，并设置响应的http method（如果不设置，则默认所有的方式都允许）。

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

优化的时候，要注意controller上的route集合保存在controller.attributes属性上，action上的route集合保存在action.attributes属性上，可以对其进行优化。

然后，在mvcoptions上，我们再为typeroutemodel添加一些扩展方法以方便使用，代码如下：

public static class mvcoptionsextensions
{
 public static typedroutemodel getroute(this mvcoptions opts, string template, action<typedroutemodel> configsetup)
 {
  return addroute(template, configsetup).forhttpmethods("get");
 }

 public static typedroutemodel postroute(this mvcoptions opts, string template, action<typedroutemodel> configsetup)
 {
  return addroute(template, configsetup).forhttpmethods("post");
 }

 public static typedroutemodel putroute(this mvcoptions opts, string template, action<typedroutemodel> configsetup)
 {
  return addroute(template, configsetup).forhttpmethods("put");
 }

 public static typedroutemodel deleteroute(this mvcoptions opts, string template, action<typedroutemodel> configsetup)
 {
  return addroute(template, configsetup).forhttpmethods("delete");
 }

 public static typedroutemodel typedroute(this mvcoptions opts, string template, action<typedroutemodel> configsetup)
 {
  return addroute(template, configsetup);
 }

 private static typedroutemodel addroute(string template, action<typedroutemodel> configsetup)
 {
  var route = new typedroutemodel(template);
  configsetup(route);

  if (typedroutingapplicationmodelconvention.routes.containskey(route.controllertype))
  {
   var controlleractions = typedroutingapplicationmodelconvention.routes[route.controllertype];
   controlleractions.add(route);
  }
  else
  {
   var controlleractions = new list<typedroutemodel> { route };
   typedroutingapplicationmodelconvention.routes.add(route.controllertype, controlleractions);
  }

  return route;
 }

 public static void enabletypedrouting(this mvcoptions opts)
 {
  opts.applicationmodelconventions.add(new typedroutingapplicationmodelconvention());
 }
}

在上述代码中，我们添加了一个enabletypedrouting扩展方法，以便向mvcoptions.applicationmodelconventions属性上添加新的typedroutingapplicationmodelconvention类型示例。

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

public static class param<tvalue>
{
 public static tvalue any
 {
  get { return default(tvalue); }
 }
}

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

opt.getroute("aboutpage/{name}", c => c.action<homecontroller>(x => x.about(param<string>.any)));

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

opt.getroute("homepage", c => c.action<homecontroller>(x => x.index())).withname("foo");

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

弊端（或bug)

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

public class productscontroller : controller
{
 [route("index")]
 public iactionresult index()
 {
  return content("index");
 }
}

然后又通过lamda表达式又定义了强类型路由，代码如下：

opt.getroute("homepage", c => c.action<productscontroller>(x => x.index()));

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

但是，上述lamda表达式方式并没有覆盖controller上定义的route特性定义，所以如果你在productscontroller上定义了route特性的话，两者就会组合在一起，例如：

[route("products")]
public class productscontroller : controller
{ 
 public iactionresult index()
 {
  return content("index");
 }
}

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

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/