MVC特性路由的提供机制

回顾：传统路由是如何提供的？

我们知道最终匹配的路由数据是保存在RouteData中的，而RouteData通常又是封装在RequestContext中的，他们是在哪里被创建的呢？没错，回到了UrlRoutingModule，我们知道UrlRoutingModule通过注册HttpApplication的PostResolveRequestCache方法来分发IHttpHandler决定ASP.NET请求最终交给哪个IHttpHandler去处理的。其实在这之前，首先会通过当前请求的HttpContextBase解析虚拟路径，匹配路由。然而这个工作是RouteCollection完成的。

public virtual void PostResolveRequestCache(HttpContextBase context)
{
    RouteData routeData = this.RouteCollection.GetRouteData(context);
    if (routeData == null)
    {
        return;
    }
    //省略了注册IHttpHandler的代码
}

反编译查看Route的GetRouteData方法

public RouteData GetRouteData(HttpContextBase httpContext)
{
    if (httpContext == null)
    {
        throw new ArgumentNullException("httpContext");
    }
    if (httpContext.Request == null)
    {
        throw new ArgumentException(SR.GetString("RouteTable_ContextMissingRequest"), "httpContext");
    }
    if (base.Count == )
    {
        return null;
    }
    bool flag = false;
    bool flag2 = false;
    if (!this.RouteExistingFiles)
    {
        flag = this.IsRouteToExistingFile(httpContext);
        flag2 = true;
        if (flag)
        {
            return null;
        }
    }
    using (this.GetReadLock())
    {
        foreach (RouteBase current in this)
        {
            RouteData routeData = current.GetRouteData(httpContext);
            if (routeData != null)
            {
                RouteData result;
                if (!current.RouteExistingFiles)
                {
                    if (!flag2)
                    {
                        flag = this.IsRouteToExistingFile(httpContext);
                    }
                    if (flag)
                    {
                        result = null;
                        return result;
                    }
                }
                result = routeData;
                return result;
            }
        }
    }
    return null;
}

这个方法乍一看也太复杂了吧，再看一下还是复杂，花了点时间理清了，就是这样子的

一句话解释：是文件都（RouteCollection和RouteBase）路由文件才成功匹配，不是文件只要路由规则匹配就成功匹配

正题：特性路由的初始化

特性路由是如何添加到路由系统中的呢？主要由AttributeRoutingMapper这个静态类实现的,先来跟随着源码一一道来。

在程序启动的时候，MVC会通过DefaultControllerFactory找到所有的控制器类型，为每一个控制器内注册的特性路由创建一个或多个Route。

public static void MapAttributeRoutes(RouteCollection routes, IInlineConstraintResolver constraintResolver)
{
    DefaultControllerFactory typesLocator =
        DependencyResolver.Current.GetService<IControllerFactory>() as DefaultControllerFactory
        ?? ControllerBuilder.Current.GetControllerFactory() as DefaultControllerFactory
        ?? new DefaultControllerFactory();
    //获得所有的控制器类型
    IReadOnlyList<Type> controllerTypes = typesLocator.GetControllerTypes();
    //开始注册
    MapAttributeRoutes(routes, controllerTypes, constraintResolver);
}

寻找特新路由的过程中会把所有创建的Route都放在SubRouteCollection这个RouteEntry只读集合中（RouteEntry封装一个Route和一个string类型的Name），最后MVC会将SubRouteCollection封装成一个Route对象（实际上是RouteBase的子类RouteCollectionRoute），添加到RouteCollection中。

public static void MapAttributeRoutes(RouteCollection routes, IEnumerable<Type> controllerTypes, IInlineConstraintResolver constraintResolver)
{
    SubRouteCollection subRoutes = new SubRouteCollection();
  AddRouteEntries(subRoutes, controllerTypes, constraintResolver);
    IReadOnlyCollection<RouteEntry> entries = subRoutes.Entries;
    if (entries.Count > )
    {
    RouteCollectionRoute aggregrateRoute = new RouteCollectionRoute(subRoutes);
    routes.Add(aggregrateRoute);
    }
}

那她是如何根据控制器来创建Route的呢？先要认识几个类型，ControllerDescriptor（控制器描述器），可以根据它获取应用在控制器上的各种特性，类似的还有ActionDescriptor（方法描述器，注意区分MethodInfo），还有ActionMethodSelector（方法选择器），方法选择器有两个属性，分别是DirectRouteMethods表示应用了特性路由的方法，StandardRouteMethods表示普通的方法。

具体处理每一个控制器类型的时候。会获取该控制器的方法选择器，对它的DirectRouteMethods和StandardRouteMethods分别处理。但两者有一个共同第一步，就是获取控制器前缀和Area前缀。控制器前缀直接从RoutePrefix特性中获取，Area前缀的话，会从RouteAreaAttribute获取，如果没有应用RouteAreaAttribute，那么就是控制器类型所在命名空间的最后一段。

internal static void AddRouteEntries(SubRouteCollection collector, ReflectedAsyncControllerDescriptor controller, IInlineConstraintResolver constraintResolver)
{
    string prefix = GetRoutePrefix(controller);
    RouteAreaAttribute area = controller.GetAreaFrom();
    string areaName = controller.GetAreaName(area);
    string areaPrefix = area != null ? area.AreaPrefix ?? area.AreaName : null;
    AsyncActionMethodSelector actionSelector = controller.Selector;
    //处理应用了特性路由的Action
    foreach (var method in actionSelector.DirectRouteMethods)
    {
        //...
    }

    //处理没有应用特性路由的Action
    foreach (var method in actionSelector.StandardRouteMethods)
    {
        //...
    }
}

处理DirectRouteMethods

首先会根据该Action的方法描述器获取应用的所有特性路由，针对每一个特性路由创建一个RouteEntry，这个核心任务是由DirectRouteBuilder的Builder方法实现的。DirectRouteBuilder包含了所有和Route相关的属性，同时还包含一个ActionDescriptor数组，大多数属性我们都是熟悉的，有必要介绍一下_actions字段，这个字段保存的是这条特性路由是应用在哪些方法上的（对于应用了特性路由的Action来说只有一个），Precedence是模板根据约束生成的一个字段，用来排序。

internal class DirectRouteBuilder : IDirectRouteBuilder
{
    private readonly ActionDescriptor[] _actions;
    private readonly bool _targetIsAction;
    private string _template;
    public DirectRouteBuilder(IReadOnlyCollection<ActionDescriptor> actions, bool targetIsAction)
    {
        if (actions == null)
        {
            throw new ArgumentNullException("actions");
        }
        _actions = actions.ToArray();
        _targetIsAction = targetIsAction;
    }
    public string Name { get; set; }

    public string Template
    {
        get
        {
            return _template;
        }
        set
        {
            ParsedRoute = null;
            _template = value;
        }
    }
    public RouteValueDictionary Defaults { get; set; }
    public RouteValueDictionary Constraints { get; set; }
    public RouteValueDictionary DataTokens { get; set; }
    public int Order { get; set; }
    public decimal Precedence { get; set; }
    public IReadOnlyCollection<ActionDescriptor> Actions
    {
        get { return _actions; }
    }

    public bool TargetIsAction
    {
        get { return _targetIsAction; }
    }

    public virtual RouteEntry Build()
    {
        //省略
    }
}

对于应用了特性路由的Action来说。会找到所有应用在该Action上的特性路由，针对每一个特新路由创建相应的RouteEntry，而这一过程就是有RouteAttribute本身完成的。在这之前，会将特新路由的一些列属性封装到DirectRouteFactoryContext中。这里IDirectRouteFactory的唯一实现就是RouteAttribute。（不知道微软为什么不在这里直接写一个静态的Build方法，而要弄出DirectRouteBuilder的Builder和DirectRouteFactoryContext这两个类，个人觉得会简单很多）

internal static RouteEntry CreateRouteEntry(string areaPrefix, string prefix, IDirectRouteFactory factory, IReadOnlyCollection<ActionDescriptor> actions, IInlineConstraintResolver constraintResolver,
 bool targetIsAction)
{
    DirectRouteFactoryContext context = new DirectRouteFactoryContext(areaPrefix, prefix, actions, constraintResolver, targetIsAction);
    RouteEntry entry = factory.CreateRoute(context);
    return entry;
}

RouteAttribute的CreateRoute包含两本分，创建一个IDirectRouteBuilder，然后在调用他的Build方法。这里也表明了，我们可以通过RouteAttribute显示指定路由的优先级。

 RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context)
 {
     IDirectRouteBuilder builder = context.CreateBuilder(Template);
     builder.Name = Name;
     builder.Order = Order;
     return builder.Build();
 }

CreateBuilder方法主要做了两件事，给路由添加控制器前缀，清除路由模板的内联约束。接下来看一下最核心的Build方法。

（1）将actions（类型为ActionDescriptor）存入DataTokens的MS_DirectRouteActions键

（2）如果定义路由的时候给定了Order，则将Order存入DataTokens的MS_DirectRouteOrder键

（3）如果特性路由的模板和约束条件改变了precedence值，也将它写入DataTokens的MS_DirectRoutePrecedence键

（4）如果actions对应的控制器描述器为同一个控制器类型，那就表示这条特性路由的控制器是有默认值的

（5）如果目标是应用了特新路由的Action，并且actions只有一个，name这条特性路由的Action也是有默认值的，同时将true写入DataTokens的MS_DirectRouteTargetIsAction键

（6）如果控制器使用的使用了RouteAreaAttribute特性，那么也将命名空间相关的值写入DataTokens中，UseNamespaceFallback用于以后控制器的查询。

public virtual RouteEntry Build()
{
    if (ParsedRoute == null)
    {
        ParsedRoute = RouteParser.Parse(Template);
    }
    RouteValueDictionary defaults;
    defaults = Copy(Defaults) ?? new RouteValueDictionary();
    RouteValueDictionary constraints = Copy(Constraints);
    RouteValueDictionary dataTokens = Copy(DataTokens) ?? new RouteValueDictionary();
    dataTokens[RouteDataTokenKeys.Actions] = _actions;
    ControllerDescriptor controllerDescriptor = GetControllerDescriptor();
    RouteAreaAttribute area = controllerDescriptor.GetAreaFrom();
    string areaName = controllerDescriptor.GetAreaName(area);
    if (areaName != null)
    {
        dataTokens[RouteDataTokenKeys.Area] = areaName;
        dataTokens[RouteDataTokenKeys.UseNamespaceFallback] = false;
        Type controllerType = controllerDescriptor.ControllerType;
        if (controllerType != null)
        {
            dataTokens[RouteDataTokenKeys.Namespaces] = new[] { controllerType.Namespace };
        }
    }
    Route route = new Route(Template, defaults, constraints, dataTokens, routeHandler: null);
    ConstraintValidation.Validate(route);
    return new RouteEntry(Name, route);
}

处理StandardRouteMethods

对于没有应用特性路由的Action来说，和应用了特新路由的Action只有两点不一样，一个是RouteAttribute来说，他们的全都是Controller上的RouteAttribute提供的，还有就是方法描述器，是所有Action，为什么这样子呢？首先应用了特性路由的Action生成的Route会默认指定他的Action名称，由于现在的Action没有指定特性路由，全都是依靠Controller类型提供了，所以就不难理解了。

特性路由的提供机制

由于特性路由最终是以一个RouteCollectionRoute添加到RouteTable中的，所以他的重写了GetRouteData。这个类比较有意思，它本身是一个路由，但它却包括了一系列（特性）路由。

（1）在集合中找到所有和当前虚拟路径匹配的路由

（2）给RouteData的Values设置键MS_DirectRouteMatches，值为所有匹配的路由

（3）取出匹配的路由的第一个，如果有controller默认值，就给RouteData的Values设置一个controller的值

internal class RouteCollectionRoute : RouteBase, IReadOnlyCollection<RouteBase>
{
    private readonly IReadOnlyCollection<RouteBase> _subRoutes;
    public override RouteData GetRouteData(HttpContextBase httpContext)
    {
        List<RouteData> matches = new List<RouteData>();
        foreach (RouteBase route in _subRoutes)
        {
            var match = route.GetRouteData(httpContext);
            if (match != null)
            {
                matches.Add(match);
            }
        }
        return CreateDirectRouteMatch(this, matches);
    }
    public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
    {
        return null;
    }

    public static RouteData CreateDirectRouteMatch(RouteBase route, List<RouteData> matches)
    {
        if (matches.Count == )
        {
            return null;
        }
        else
        {
            var routeData = new RouteData();
            routeData.Route = route;
            routeData.RouteHandler = new MvcRouteHandler();
            ControllerDescriptor controllerDescriptor = matches[].GetTargetControllerDescriptor();
            if (controllerDescriptor != null)
            {
                routeData.Values[RouteDataTokenKeys.Controller] = controllerDescriptor.ControllerName;
            }
            return routeData;
        }
    }
}

可能也许有人会有疑问，特性路由最后也没有匹配一个具体的Route，事实上就是这样子的，RouteCollectionRoute就是一个具体的路由，在控制器的匹配工作上还要用到这里的知识，所以任重而道远哈，不过说回来这篇博客是我有史以来耗时最长的一个了。。鼓励一下自己！！！