ASP.NET Web API 框架研究 Web Host模式路由及将请求转出到消息处理管道

　　Web Host 模式下的路由本质上还是通过ASP.NET 路由系统来进行路由的，只是通过继承和组合的方式对ASP.NET路由系统的内部的类进行了一些封装，产生自己专用一套类结构，功能逻辑基本都是一样的。

　　简单的概括起来，Web Host模式下的ASP.NET Web API在Web应用中注册的路由（HostedHttpRoute）最终会转换成ASP.NET 全局路由表中的Route(HttpWebRoute),ASP.NET路由系统会对请求进行匹配，把匹配的路由变量数据存放到RequestContext中，再通过UrlRoutingModule从匹配的Route（从RequestContext中获取，见ASP.NET路由部分代码）中获取IRouteHandler,即HttpControllerRouteHandler，其提供的HttpControllerHandler最终会创建出消息处理管道，即触发HttpServer，消息处理管道的第一个消息处理器。

一、涉及的类及源码分析　

　　Web Host 模式下的类基本都在System.Web.Http.WebHost程序集中,相比Web API的接口基本都在System.Web.Http程序集中，包括GlobalConfiguration和HttpConfiguration类，主要类和成员如下图：

　　

　　简要说明：

　　在静态类GlobalConfiguration中创建了HttpConfiguration对象，其构造参数默认指定为HostedHttpRouteCollection，而该集合的构造函数指定为RouteCollection类型的ASP.NET 路由系统全局路由表，通过组合方式对其进行了封装，将其作为HostedHttpRouteCollection的一个属性，用来存放ASP.NET 路由中的Route对象，路由注册时加入路由表中的路由对象HostedHttpRoute最终都要转换成Route对象。

　　HttpConfiguration config = new HttpConfiguration(new HostedHttpRouteCollection(RouteTable.Routes));

　　而HostedHttpRouteCollection继承自HttpRouteCollection,在其重写的CreateRoute方法中，创建的是一个HostedHttpRoute路由对象

　　public override IHttpRoute CreateRoute(string uriTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IDictionary<string, object> 　　　　dataTokens, 　　HttpMessageHandler handler)

　　{

　　　　//...

　　　　return new HostedHttpRoute(uriTemplate, defaults, constraints, dataTokens, handler);

　　}

　　而在创建HostedHttpRoute对象时候,在构造函数中，直接创建HttpWebRoute对象，并直接指定IRouteHandler为HttpControllerRouteHandler

　　OriginalRoute = new HttpWebRoute(uriTemplate, routeDefaults, routeConstraints, routeDataTokens, HttpControllerRouteHandler.Instance, this);

　　而HttpWebRoute直接继承自Route，所以本质上还是利用了ASP.NET路由的功能。

　　另外，HttpControllerRouteHandler其方法GetHttpHandler默认返回的是HttpControllerHandler，也是直接指定

　　protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
　　{
　　　　return new HttpControllerHandler(requestContext.RouteData);
　　}

　　在其构造函数中，默认传入了GlobalConfiguration.DefaultServer，其在GlobalConfiguration中指定的是HttpServer，其是ASP.NET Web API 消息处理管道的第一个处理器（HttpMessageHandler）

　　public HttpControllerHandler(RouteData routeData)
　　: this(routeData, GlobalConfiguration.DefaultServer)
　　{
　　}

　　HttpControllerHandler是一个HttpHandler

　　 public class HttpControllerHandler : HttpTaskAsyncHandler

　　 public abstract class HttpTaskAsyncHandler : IHttpAsyncHandler, IHttpHandler

　　 在其ProcessRequestAsync方法中通过以下语句将请求转接入消息处理管道中。

　　response = await _server.SendAsync(request, cancellationToken)

1、HttpWebRoute 

　　HttpWebRoute 类直接继承ASP.NET路由中的Route，重写了主要方法GetRouteData、GetVirtualPath和ProcessConstraint，其主要功能还是调用基类的同名方法（如base.GetRouteData），另外，还有个HttpRoute属性，其是创建它的HostedHttpRoute对象，简要说明中已有描述，后边也会再次指出，约束检查还是用IHttpRouteConstraint。

　　可知，HttpWebRoute 是Web Host模式下ASP.NET Web API实际执行路由功能的对象，而其实际又使用（继承）了ASP.NET路由系统的Route对象来实现的，实现了ASP.NET Web API路由功能和ASP.NET路由的链接。另外，HttpWebRoute对象是通过HostedHttpRoute对象创建的。

　　总结下来它是对ASP.NET路由系统中Route对象封装。

　　//继承ASP.NET路由的Route

　　internal class HttpWebRoute : Route
　　{
　　　　internal const string HttpRouteKey = "httproute";

　　　　public HttpWebRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler routeHandler, 　　　　　　IHttpRoute httpRoute)
　　　　　　: base(url, defaults, constraints, dataTokens, routeHandler)
　　　　{
　　　　　　if (httpRoute == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("httpRoute");
　　　　　　}

　　　　　　HttpRoute = httpRoute;
　　　　}

　　　　//创建它的IHttpRoute 即HostedHttpRoute
　　　　public IHttpRoute HttpRoute { get; private set; }

　　　　//重写了约束检查处理功能，优先使用IHttpRouteConstraint

　　　　//注意请求是HttpContextBase类型的HttpContext,在ASP.NET路由中参数用得是HttpContextBase类型而不是HttpRequestMessage类型

　　　　protected override bool ProcessConstraint(HttpContextBase httpContext, object constraint, string parameterName, RouteValueDictionary values, RouteDirection 　　　　　　routeDirection)
　　　　{
　　　　　　ValidateConstraint(HttpRoute.RouteTemplate, parameterName, constraint);

　　　　　　IHttpRouteConstraint httpRouteConstraint = constraint as IHttpRouteConstraint;
　　　　　　if (httpRouteConstraint != null)
　　　　　　{

　　　　　　　　//如果是IHttpRouteConstraint

　　　　　　　　//创建一个HttpRequestMessage 
　　　　　　　　HttpRequestMessage request = httpContext.GetOrCreateHttpRequestMessage();
　　　　　　　　return httpRouteConstraint.Match(request, HttpRoute, parameterName, values, ConvertRouteDirection(routeDirection));
　　　　　　}

　　　　　　//不是的话，调用基类ASP.NET路由对应检查功能

　　　　　　return base.ProcessConstraint(httpContext, constraint, parameterName, values, routeDirection);
　　　　}

　　　　//重写了路由解析功能，注意参数也是HttpContextBase

　　　　//注意返回值都是ASP.NET路由中的数据对象RouteData

　　　　public override RouteData GetRouteData(HttpContextBase httpContext)
　　　　{
　　　　　　try
　　　　　　{
　　　　　　　　if (HttpRoute is HostedHttpRoute)
　　　　　　　　{

　　　　　　　　　　//Web Host模式下，就调用基类ASP.NET路由对应的功能
　　　　　　　　　　return base.GetRouteData(httpContext);
　　　　　　　　}
　　　　　　　　else
　　　　　　　　{

　　　　　　　　　　//其他情况就调用，创建本对象的HttpRoute自身的功能，也要构建HttpRequestMessage 
　　　　　　　　　　HttpRequestMessage request = httpContext.GetOrCreateHttpRequestMessage();
　　　　　　　　　　IHttpRouteData data = HttpRoute.GetRouteData(httpContext.Request.ApplicationPath, request);
　　　　　　　　　　return data == null ? null : data.ToRouteData();
　　　　　　　　}
　　　　　　}
　　　　　　catch (Exception exception)
　　　　　　{
　　　　　　　　ExceptionDispatchInfo exceptionInfo = ExceptionDispatchInfo.Capture(exception);
　　　　　　　　return new RouteData(this, new HttpRouteExceptionRouteHandler(exceptionInfo));
　　　　　　}
　　　　}

　　　　//重写了生成URL功能，主要逻辑和GetRouteData情况一样

　　　　public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
　　　　{
　　　　　　if (!values.ContainsKey(HttpRouteKey))
　　　　　　{
　　　　　　　　return null;
　　　　　　}

　　　　　　RouteValueDictionary newValues = GetRouteDictionaryWithoutHttpRouteKey(values);

　　　　　　if (HttpRoute is HostedHttpRoute)
　　　　　　{
　　　　　　　　return base.GetVirtualPath(requestContext, newValues);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　HttpRequestMessage request = requestContext.HttpContext.GetOrCreateHttpRequestMessage();
　　　　　　　　IHttpVirtualPathData virtualPathData = HttpRoute.GetVirtualPath(request, values);

　　　　　　　　return virtualPathData == null ? null : new VirtualPathData(this, virtualPathData.VirtualPath);
　　　　　　}
　　　　}

　　　　private static RouteValueDictionary GetRouteDictionaryWithoutHttpRouteKey(IDictionary<string, object> routeValues)
　　　　{
　　　　　　var newRouteValues = new RouteValueDictionary();
　　　　　　foreach (var routeValue in routeValues)
　　　　　　{
　　　　　　　　if (!String.Equals(routeValue.Key, HttpRouteKey, StringComparison.OrdinalIgnoreCase))
　　　　　　　　{
　　　　　　　　　　newRouteValues.Add(routeValue.Key, routeValue.Value);
　　　　　　　　}
　　　　　　}
　　　　　　return newRouteValues;
　　　　}

　　　　private static HttpRouteDirection ConvertRouteDirection(RouteDirection routeDirection)
　　　　{
　　　　　　if (routeDirection == RouteDirection.IncomingRequest)
　　　　　　{
　　　　　　　　return HttpRouteDirection.UriResolution;
　　　　　　}

　　　　　　if (routeDirection == RouteDirection.UrlGeneration)
　　　　　　{
　　　　　　　　return HttpRouteDirection.UriGeneration;
　　　　　　}

　　　　　　throw Error.InvalidEnumArgument("routeDirection", (int)routeDirection, typeof(RouteDirection));
　　　　}

　　　　internal static void ValidateConstraint(string routeTemplate, string name, object constraint)
　　　　{
　　　　　　if (constraint is IHttpRouteConstraint)
　　　　　　{
　　　　　　　　return;
　　　　　　}

　　　　　　if (constraint is IRouteConstraint)
　　　　　　{
　　　　　　　　return;
　　　　　　}

　　　　　　if (constraint is string)
　　　　　　{
　　　　　　　　return;
　　　　　　}

　　　　　　throw CreateInvalidConstraintTypeException(routeTemplate, name);
　　　　}

　　　　private static Exception CreateInvalidConstraintTypeException(string routeTemplate, string name)
　　　　{
　　　　　　return Error.InvalidOperation(
　　　　　　　　SRResources.Route_ValidationMustBeStringOrCustomConstraint,
　　　　　　　　name,
　　　　　　　　routeTemplate,
　　　　　　　　typeof(IHttpRouteConstraint).FullName,
　　　　　　　　typeof(IRouteConstraint).FullName);
　　　　}
　　}

2、HostedHttpRoute

　　 HostedHttpRoute是全局路由表（HostedHttpRouteCollection）创建路由（调用CreateRoute方法）时候创建的对象，并将其添加到路由表中，在其构造函数中创建了一个HttpWebRoute（真正实施路由的对象，即1、HttpWebRoute）对象的OriginalRoute 属性，从前边得知HttpWebRoute继承Route，相当于是对ASP.NET 路由功能的间接封装。

　　另外，该类实现了HttpRoute接口，其中的GetRouteData、GetVirtualPath参数的去求上下文信息是之前保存在HttpRequestMessage的属性字典中，KEY值为MS_HttpContext,因为ASP.NET 路由中对应方法是用HttpContext的，而不是HttpRequestMessage，所以需要从其字典属性中去取对应请求上下文数据。

　　总结下来它是对ASP.NET路由系统中Route对象间接封装。

　　internal class HostedHttpRoute : IHttpRoute
　　{
　　　　public HostedHttpRoute(string uriTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IDictionary<string, object> dataTokens, 　　　　　　HttpMessageHandler handler)
　　　　{
　　　　　　RouteValueDictionary routeDefaults = defaults != null ? new RouteValueDictionary(defaults) : null;
　　　　　　RouteValueDictionary routeConstraints = constraints != null ? new RouteValueDictionary(constraints) : null;
　　　　　　RouteValueDictionary routeDataTokens = dataTokens != null ? new RouteValueDictionary(dataTokens) : null;

　　　　　　//直接创建HttpWebRoute，保存到OriginalRoute 属性，同时指定了HttpControllerRouteHandler作为IRouteHandler
　　　　　　OriginalRoute = new HttpWebRoute(uriTemplate, routeDefaults, routeConstraints, routeDataTokens, HttpControllerRouteHandler.Instance, this);
　　　　　　Handler = handler;
　　　　}

　　　　public string RouteTemplate
　　　　{
　　　　　　get { return OriginalRoute.Url; }
　　　　}

　　　　public IDictionary<string, object> Defaults
　　　　{
　　　　　　get { return OriginalRoute.Defaults; }
　　　　}

　　　　public IDictionary<string, object> Constraints
　　　　{
　　　　　　get { return OriginalRoute.Constraints; }
　　　　}

　　　　public IDictionary<string, object> DataTokens
　　　　{
　　　　　　get { return OriginalRoute.DataTokens; }
　　　　}

　　　　public HttpMessageHandler Handler { get; private set; }

　　　　internal Route OriginalRoute { get; private set; }

　　　　//实现了接口的GetRouteData

　　　　public IHttpRouteData GetRouteData(string rootVirtualPath, HttpRequestMessage request)
　　　　{
　　　　　　if (rootVirtualPath == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("rootVirtualPath");
　　　　　　}

　　　　　　if (request == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("request");
　　　　　　}

　　　　　　//从HttpRequestMessage字典属性中获取Key为MS_HttpContext的上下文数据

　　　　　　HttpContextBase httpContextBase = request.GetHttpContext();
　　　　　　if (httpContextBase == null)
　　　　　　{
　　　　　　　　httpContextBase = new HttpRequestMessageContextWrapper(rootVirtualPath, request);
　　　　　　}

　　　　　　//通过OriginalRoute属性的同名方法调用ASP.NET路由的同名方法，并把上下文数据作为参数

　　　　　　RouteData routeData = OriginalRoute.GetRouteData(httpContextBase);
　　　　　　if (routeData != null)
　　　　　　{

　　　　　　　　//对返回的ASP.NET 路由数据RouteData封装成HostedHttpRouteData
　　　　　　　　return new HostedHttpRouteData(routeData);
　　　　　　}

　　　　　　return null;
　　　　}

　　　　public IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, IDictionary<string, object> values)
　　　　{
　　　　　　if (request == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("request");
　　　　　　}

　　　　　　//从HttpRequestMessage字典属性中获取Key为MS_HttpContext的上下文数据

　　　　　　HttpContextBase httpContextBase = request.GetHttpContext();
　　　　　　if (httpContextBase != null)
　　　　　　{

　　　　　　　　//还要从HttpRequestMessage中获取对应解析好的路由数据
　　　　　　　　HostedHttpRouteData routeData = request.GetRouteData() as HostedHttpRouteData;
　　　　　　　　if (routeData != null)
　　　　　　　　{

　　　　　　　　　　//构建出一个RequestContext 对象，其封装了httpContextBase和routeData .OriginalRouteData（即RouteData）
　　　　　　　　　　RequestContext requestContext = new RequestContext(httpContextBase, routeData.OriginalRouteData);

　　　　　　　　　　//通过OriginalRoute调用ASP.NET路由系统的同名方法,并以RequestContext 作为参数
　　　　　　　　　　VirtualPathData virtualPathData = OriginalRoute.GetVirtualPath(requestContext, new RouteValueDictionary(values));
　　　　　　　　　　if (virtualPathData != null)
　　　　　　　　　　{

　　　　　　　　　　　　//封装成HostedHttpVirtualPathData，routeData.Route为HttpWebRoute
　　　　　　　　　　　　return new HostedHttpVirtualPathData(virtualPathData, routeData.Route);
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}

　　　　　　return null;
　　　　}
　　}

3、HostedHttpRouteData 

　　是对ASP.NET路由中RouteData 的封装，其属性OriginalRouteData保存了被封装的RouteData，被封装的RouteData（即OriginalRouteData）的Route属性是HttpWebRoute。

　　internal class HostedHttpRouteData : IHttpRouteData
　　{
　　　　public HostedHttpRouteData(RouteData routeData)
　　　　{
　　　　　　if (routeData == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("routeData");
　　　　　　}

　　　　　　OriginalRouteData = routeData;

　　　　　　HttpWebRoute route = routeData.Route as HttpWebRoute;
　　　　　　Route = route == null ? null : route.HttpRoute;
　　　　}

　　　　public IHttpRoute Route { get; private set; }

　　　　public IDictionary<string, object> Values
　　　　{
　　　　　　get { return OriginalRouteData.Values; }
　　　　}

　　　　internal RouteData OriginalRouteData { get; private set; }
　　}

4、HostedHttpVirtualPathData 

　　是对ASP.NET路由中VirtualPathData 的封装，返回的VirtualPath就是对应被封装的VirtualPathData 的VirtualPath属性

　　internal class HostedHttpVirtualPathData : IHttpVirtualPathData
　　{
　　　　private readonly VirtualPathData _virtualPath;

　　　　public HostedHttpVirtualPathData(VirtualPathData virtualPath, IHttpRoute httpRoute)
　　　　{
　　　　　　if (virtualPath == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("route");
　　　　　　}

　　　　　　_virtualPath = virtualPath;
　　　　　　Route = httpRoute;
　　　　}

　　　　public IHttpRoute Route { get; private set; }

　　　　public string VirtualPath
　　　　{
　　　　　　get { return _virtualPath.VirtualPath; }
　　　　　　set
　　　　　　{
　　　　　　　　if (value == null)
　　　　　　　　{
　　　　　　　　　　throw Error.PropertyNull();
　　　　　　　　}
　　　　　　　　_virtualPath.VirtualPath = value;
　　　　　　}
　　　　}
　　}

5、HostedHttpRouteCollection 

　　是Web Host模式下的全局路由表，由GlobalConfiguration类构建HttpConfiguration对象时候，在构造函数中默认指定，在创建对象HostedHttpRouteCollection 本身时候，在构造函数中，又指定了一个ASP.NET路由的路由表RouteTable.Routes,其用来真正保存最后的路由对象Route,路由注册时候创建的对象，最终都要转换成Route，并存放到ASP.NET路由的路由表RouteTable.Routes中，其类型为RouteCollection ，GlobalConfiguration中有下边这么一句，都是默认写死的

　　HttpConfiguration config = new HttpConfiguration(new HostedHttpRouteCollection(RouteTable.Routes));

　　简要说明中已经说过，后边还会说明。

　　另外，其继承自HttpRouteCollection，重写其主要方法，GetRouteData和GetVirtualPath方法内部调用的是内部路由表RouteTable.Routes类型为RouteCollection的对应同名方法。

　　注册路由时候，HttpRouteCollection定义了扩展方法MapHttpRoute，其内部分别调用了CreateRoute和Add方法，来完成注册，如下代码片段

　　//先创建建路由
　　IHttpRoute route = routes.CreateRoute(routeTemplate, defaultsDictionary, constraintsDictionary, dataTokens: null, handler: handler);

　　//再往路由表里添加路由
　　routes.Add(name, route);

　　由于扩展方法有继承性，扩展一个类型的时候，其也扩展了派生类，所以实际是调用HostedHttpRouteCollection对应CreateRoute和Add方法。

　　总结下来它是对ASP.NET全局路由表的封装，通过组合方式

　　internal class HostedHttpRouteCollection : HttpRouteCollection
　　{
　　　　private readonly RouteCollection _routeCollection;
　　　　private readonly string _virtualPathRoot;

　　　　public HostedHttpRouteCollection(RouteCollection routeCollection)
　　　　　　: this(routeCollection, virtualPathRoot: null)
　　　　{
　　　　}

　　　　public HostedHttpRouteCollection(RouteCollection routeCollection, string virtualPathRoot)
　　　　{
　　　　　　if (routeCollection == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("routeCollection");
　　　　　　}

　　　　　　_routeCollection = routeCollection;
　　　　　　_virtualPathRoot = virtualPathRoot;
　　　　}

　　　　public override string VirtualPathRoot
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　if (_virtualPathRoot == null)
　　　　　　　　{
　　　　　　　　　　return HostingEnvironment.ApplicationVirtualPath;
　　　　　　　　}
　　　　　　　　else
　　　　　　　　{
　　　　　　　　　　return _virtualPathRoot;
　　　　　　　　}
　　　　　　}
　　　　}

　　　　public override int Count
　　　　{
　　　　　　get { return _routeCollection.Count; }
　　　　}

　　　　public override IHttpRoute this[string name]
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　HttpWebRoute route = _routeCollection[name] as HttpWebRoute;
　　　　　　　　if (route != null)
　　　　　　　　{
　　　　　　　　　　return route.HttpRoute;
　　　　　　　　}

　　　　　　　　throw Error.KeyNotFound();
　　　　　　}
　　　　}

　　　　public override IHttpRoute this[int index]
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　HttpWebRoute route = _routeCollection[index] as HttpWebRoute;
　　　　　　　　if (route != null)
　　　　　　　　{
　　　　　　　　　　return route.HttpRoute;
　　　　　　　　}

　　　　　　　　throw Error.ArgumentOutOfRange("index", index, SRResources.RouteCollectionOutOfRange);
　　　　　　}
　　　　}

　　　　public override IHttpRouteData GetRouteData(HttpRequestMessage request)
　　　　{
　　　　　　if (request == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("request");
　　　　　　}

　　　　　　HttpContextBase httpContextBase = request.GetHttpContext();
　　　　　　if (httpContextBase == null)
　　　　　　{
　　　　　　　　httpContextBase = new HttpRequestMessageContextWrapper(VirtualPathRoot, request);
　　　　　　}

　　　　　　if (httpContextBase.GetHttpRequestMessage() == null)
　　　　　　{
　　　　　　　　httpContextBase.SetHttpRequestMessage(request);
　　　　　　}

　　　　　　//调用内部ASP.NET路由的全局路由表对应方法

　　　　　　RouteData routeData = _routeCollection.GetRouteData(httpContextBase);

　　　　　　if (routeData != null && !(routeData.RouteHandler is System.Web.Routing.StopRoutingHandler))
　　　　　　{

　　　　　　　　//返回HostedHttpRouteData，返回结果的声明是IHttpRouteData
　　　　　　　　return new HostedHttpRouteData(routeData);
　　　　　　}

　　　　　　return null;
　　　　}

　　　　public override IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, string name, IDictionary<string, object> values)
　　　　{
　　　　　　if (request == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("request");
　　　　　　}

　　　　　　HttpContextBase httpContextBase = request.GetHttpContext();
　　　　　　if (httpContextBase == null)
　　　　　　{
　　　　　　　　httpContextBase = new HttpRequestMessageContextWrapper(VirtualPathRoot, request);
　　　　　　}

　　　　　　if (httpContextBase.GetHttpRequestMessage() == null)
　　　　　　{
　　　　　　　　httpContextBase.SetHttpRequestMessage(request);
　　　　　　}

　　　　　　IHttpRouteData routeData = request.GetRouteData();
　　　　　　if (routeData == null)
　　　　　　{
　　　　　　　　return null;
　　　　　　}

　　　　　　RequestContext requestContext = new RequestContext(httpContextBase, routeData.ToRouteData());
　　　　　　RouteValueDictionary routeValues = values != null ? new RouteValueDictionary(values) : new RouteValueDictionary();

　　　　　　//调用内部ASP.NET路由的全局路由表对应方法
　　　　　　VirtualPathData virtualPathData = _routeCollection.GetVirtualPath(requestContext, name, routeValues);

　　　　　　if (virtualPathData != null)
　　　　　　{
　　　　　　　　if (!(virtualPathData.Route is HttpWebRoute))
　　　　　　　　{
　　　　　　　　　　if (routeValues.Remove(HttpWebRoute.HttpRouteKey))
　　　　　　　　　　{
　　　　　　　　　　　　VirtualPathData virtualPathDataWithoutHttpRouteValue = _routeCollection.GetVirtualPath(requestContext, name, routeValues);
　　　　　　　　　　　　if (virtualPathDataWithoutHttpRouteValue != null)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　virtualPathData = virtualPathDataWithoutHttpRouteValue;
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　}

　　　　　　　　//返回HostedHttpVirtualPathData，返回结果的声明是IHttpVirtualPathData

　　　　　　　　return new HostedHttpVirtualPathData(virtualPathData, routeData.Route);
　　　　　　}

　　　　　　return null;
　　　　}

　　　　//路由映射时候创建路由
　　　　public override IHttpRoute CreateRoute(string uriTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IDictionary<string, object> 　　　　　　dataTokens, HttpMessageHandler handler)
　　　　{
　　　　　　if (constraints != null)
　　　　　　{
　　　　　　　　foreach (var constraint in constraints)
　　　　　　　　{
　　　　　　　　　　ValidateConstraint(uriTemplate, constraint.Key, constraint.Value);
　　　　　　　　}
　　　　　　}

　　　　　　//每次创建的是这个路由对象，内部创建了一个继承自Route的HttpWebRoute对象

　　　　　　return new HostedHttpRoute(uriTemplate, defaults, constraints, dataTokens, handler);
　　　　}

　　　　protected override void ValidateConstraint(string routeTemplate, string name, object constraint)
　　　　{
　　　　　　HttpWebRoute.ValidateConstraint(routeTemplate, name, constraint);
　　　　}

　　　　//添加一个路由对象

　　　　public override void Add(string name, IHttpRoute route)
　　　　{

　　　　　　//往内部ASP.NET路由系统全局路由表添加Route对象，通过ToRoute方法转换
　　　　　　_routeCollection.Add(name, route.ToRoute());
　　　　}

　　　　public override void Clear()
　　　　{
　　　　　　_routeCollection.Clear();
　　　　}

　　　　public override bool Contains(IHttpRoute item)
　　　　{
　　　　　　foreach (RouteBase route in _routeCollection)
　　　　　　{
　　　　　　　　HttpWebRoute webRoute = route as HttpWebRoute;
　　　　　　　　if (webRoute != null && webRoute.HttpRoute == item)
　　　　　　　　{
　　　　　　　　　　return true;
　　　　　　　　}
　　　　　　}

　　　　　　return false;
　　　　}

　　　　public override bool ContainsKey(string name)
　　　　{
　　　　　　return _routeCollection[name] != null;
　　　　}

　　　　public override IEnumerator<IHttpRoute> GetEnumerator()
　　　　{
　　　　　　return _routeCollection
　　　　　　.OfType<HttpWebRoute>()
　　　　　　.Select(httpWebRoute => httpWebRoute.HttpRoute)
　　　　　　.GetEnumerator();
　　　　}

　　　　public override bool TryGetValue(string name, out IHttpRoute route)
　　　　{
　　　　　　HttpWebRoute rt = _routeCollection[name] as HttpWebRoute;
　　　　　　if (rt != null)
　　　　　　{
　　　　　　　　route = rt.HttpRoute;
　　　　　　　　return true;
　　　　　　}

　　　　　　route = null;
　　　　　　return false;
　　　　}

　　　　private static NotSupportedException NotSupportedByRouteCollection()
　　　　{
　　　　　　return Error.NotSupported(SRResources.RouteCollectionNotSupported, typeof(HostedHttpRouteCollection).Name);
　　　　}

　　　　private static NotSupportedException NotSupportedByHostedRouteCollection()
　　　　{
　　　　　　return Error.NotSupported(SRResources.RouteCollectionUseDirectly, typeof(RouteCollection).Name);
　　　　}
　　}

6、GlobalConfiguration

　　public static class GlobalConfiguration
　　{
　　　　private static Lazy<HttpConfiguration> _configuration = CreateConfiguration();

　　　　private static Lazy<HttpMessageHandler> _defaultHandler = CreateDefaultHandler();

　　　　private static Lazy<HttpServer> _defaultServer = CreateDefaultServer();

　　　　public static HttpConfiguration Configuration
　　　　{
　　　　　　get { return _configuration.Value; }
　　　　}

　　　　public static HttpMessageHandler DefaultHandler
　　　　{
　　　　　　get { return _defaultHandler.Value; }
　　　　}

　　　　public static HttpServer DefaultServer
　　　　{
　　　　　　get { return _defaultServer.Value; }
　　　　}

　　　　public static void Configure(Action<HttpConfiguration> configurationCallback)
　　　　{
　　　　　　if (configurationCallback == null)
　　　　　　{
　　　　　　　　throw new ArgumentNullException("configurationCallback");
　　　　　　}

　　　　　　configurationCallback.Invoke(Configuration);
　　　　　　Configuration.EnsureInitialized();
　　　　}

　　　　internal static void Reset()
　　　　{
　　　　　　_configuration = CreateConfiguration();
　　　　　　_defaultHandler = CreateDefaultHandler();
　　　　　　_defaultServer = CreateDefaultServer();
　　　　}

　　　　private static Lazy<HttpConfiguration> CreateConfiguration()
　　　　{
　　　　　　return new Lazy<HttpConfiguration>(() =>
　　　　　　{

　　　　　　　//默认指定,HostedHttpRouteCollection,并传入ASP.NET路由系统的全局路由表
　　　　　　　　HttpConfiguration config = new HttpConfiguration(new HostedHttpRouteCollection(RouteTable.Routes));
　　　　　　　　ServicesContainer services = config.Services;
　　　　　　　　Contract.Assert(services != null);
　　　　　　　　services.Replace(typeof(IAssembliesResolver), new WebHostAssembliesResolver());
　　　　　　　　services.Replace(typeof(IHttpControllerTypeResolver), new WebHostHttpControllerTypeResolver());
　　　　　　　　services.Replace(typeof(IHostBufferPolicySelector), new WebHostBufferPolicySelector());
　　　　　　　　services.Replace(typeof(IExceptionHandler),
　　　　　　　　new WebHostExceptionHandler(services.GetExceptionHandler()));
　　　　　　　　return config;
　　　　　　});
　　　　}

　　　　private static Lazy<HttpMessageHandler> CreateDefaultHandler()
　　　　{
　　　　　　return new Lazy<HttpMessageHandler>(() => new HttpRoutingDispatcher(_configuration.Value));
　　　　}

　　　　//默认指定第一个HttpMessageHandler

　　　　private static Lazy<HttpServer> CreateDefaultServer()
　　　　{
　　　　　　return new Lazy<HttpServer>(() => new HttpServer(_configuration.Value, _defaultHandler.Value));
　　　　}

　　}

7、HttpControllerRouteHandler 

　　在HostedHttpRoute构造函数中创建HttpWebRoute对象时候，已经直接指定每个请求路由匹配后使用的IRouteHandler，其返回的IHttpHandler 用来处理请求。

　　OriginalRoute = new HttpWebRoute(uriTemplate, routeDefaults, routeConstraints, routeDataTokens, HttpControllerRouteHandler.Instance, this);

　　public class HttpControllerRouteHandler : IRouteHandler
　　{
　　　　private static readonly Lazy<HttpControllerRouteHandler> _instance =
　　　　　　new Lazy<HttpControllerRouteHandler>(() => new HttpControllerRouteHandler(), isThreadSafe: true);

　　　　protected HttpControllerRouteHandler()
　　　　{
　　　　}

　　　　public static HttpControllerRouteHandler Instance
　　　　{
　　　　　　get { return _instance.Value; }
　　　　}

　　　　IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext)
　　　　{
　　　　　　return GetHttpHandler(requestContext);
　　　　}

　　　　protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
　　　　{

　　　　　//直接new了HttpControllerHandler
　　　　　　return new HttpControllerHandler(requestContext.RouteData);
　　　　}
　　}

8、HttpControllerHandler 

　　public class HttpControllerHandler : HttpTaskAsyncHandler
　　{
　　　　internal static readonly string OwinEnvironmentHttpContextKey = "owin.Environment";

　　　　internal static readonly string OwinEnvironmentKey = "MS_OwinEnvironment";

　　　　private static readonly Lazy<Action<HttpContextBase>> _suppressRedirectAction =
　　　　　　new Lazy<Action<HttpContextBase>>(
　　　　　　　　() =>
　　　　　　　　{
　　　　　　　　　　if (!SuppressFormsAuthRedirectHelper.GetEnabled(WebConfigurationManager.AppSettings))
　　　　　　　　　　{
　　　　　　　　　　　　return httpContext => { };
　　　　　　　　　　}

　　　　　　　　　　return httpContext => httpContext.Response.SuppressFormsAuthenticationRedirect = true;
　　　　　　　　});

　　　　private static readonly Lazy<IHostBufferPolicySelector> _bufferPolicySelector =
　　　　　　new Lazy<IHostBufferPolicySelector>(() => GlobalConfiguration.Configuration.Services.GetHostBufferPolicySelector());

　　　　private static readonly Lazy<IExceptionHandler> _exceptionHandler = new Lazy<IExceptionHandler>(() =>
　　　　　　ExceptionServices.GetHandler(GlobalConfiguration.Configuration));
　　　　private static readonly Lazy<IExceptionLogger> _exceptionLogger = new Lazy<IExceptionLogger>(() =>
　　　　　　ExceptionServices.GetLogger(GlobalConfiguration.Configuration));

　　　　private static readonly Func<HttpRequestMessage, X509Certificate2> _retrieveClientCertificate = new Func<HttpRequestMessage, X509Certificate2>　　　　　　　　                   (RetrieveClientCertificate);

　　　　private readonly IHttpRouteData _routeData;
　　　　private readonly HttpMessageInvoker _server;

　　　　//构造函数中，默认制定了第一个HttpMessageHandler为HttpServer
　　　　public HttpControllerHandler(RouteData routeData)
　　　　: this(routeData, GlobalConfiguration.DefaultServer)
　　　　{
　　　　}

　　　　public HttpControllerHandler(RouteData routeData, HttpMessageHandler handler)
　　　　{
　　　　　　if (routeData == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("routeData");
　　　　　　}
　　　　　　if (handler == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("handler");
　　　　　　}

　　　　　　_routeData = new HostedHttpRouteData(routeData);
　　　　　　_server = new HttpMessageInvoker(handler);
　　　　}

　　　　public override Task ProcessRequestAsync(HttpContext context)
　　　　{
　　　　　　return ProcessRequestAsyncCore(new HttpContextWrapper(context));
　　　　}

　　　　internal async Task ProcessRequestAsyncCore(HttpContextBase contextBase)
　　　　{

　　　　　　//创建HttpRequestMessage对象

　　　　　　HttpRequestMessage request = contextBase.GetHttpRequestMessage() ?? ConvertRequest(contextBase);

　　　　　　//把路由数据存放到HttpRequestMessage对象的属性字典中

　　　　　　request.SetRouteData(_routeData);
　　　　　　CancellationToken cancellationToken = contextBase.Response.GetClientDisconnectedTokenWhenFixed();
　　　　　　HttpResponseMessage response = null;

　　　　　　try
　　　　　　{

　　　　　　　　//调用方法将请求转出得到消息管道的第一个处理器，HttpServer(HttpMessageHandler)
　　　　　　　　response = await _server.SendAsync(request, cancellationToken);
　　　　　　　　await CopyResponseAsync(contextBase, request, response, _exceptionLogger.Value, _exceptionHandler.Value,
　　　　　　　　　　cancellationToken);
　　　　　　}
　　　　　　catch (OperationCanceledException)
　　　　　　{
　　　　　　　　contextBase.Request.Abort();
　　　　　　}
　　　　　　finally
　　　　　　{
　　　　　　　　request.DisposeRequestResources();
　　　　　　　　request.Dispose();

　　　　　　　　if (response != null)
　　　　　　　　{
　　　　　　　　　　response.Dispose();
　　　　　　　　}
　　　　　　}
　　　　}

　　}

二、路由注册

　　我们新建一个Web应用程序的Web API项目时候，默认生成路由配置如下图：

　　

　　那怎么会寄宿到Web Host呢，而且还要用到前边介绍的这些类，来完成与ASP.NET 路由系统的集成，我们看到项目自动引用了程序集System.Web.Http.WebHost程序集，我们的Web Host模式的类都定义到这里，另外，根据前边介绍GlobalConfiguration默认使用了其中的类

　　

　　但是下边的代码明明是调用的是上一篇介绍的接口方法，config.Routes的类型是HttpRouteCollection,MapHttpRoute是其扩展方法，

　　config.Routes.MapHttpRoute

　　从前边知道，GlobalConfiguration指定的HostedHttpRouteCollection继承自HttpRouteCollection，对还是下边这句

　　HttpConfiguration config = new HttpConfiguration(new HostedHttpRouteCollection(RouteTable.Routes));

　　所以config.Routes实际类型是HostedHttpRouteCollection，再利用扩展方法的继承性，MapHttpRoute方法中调用的方法（其中调用了HttpRouteCollection的CreateRoute和Add方法），实际是HostedHttpRouteCollection中的方法。

　　所以，我们实现了在Web Host模式下的路由注册。

三、路由解析

　　HostedHttpRouteCollection中的GetRouteData方法，其实际调用的是内部封装的ASP.NET路由的全局路由表（RouteCollection类型）的同名方法，请参考前边注释，或参考ASP.NET路由部分。

四、生成URL

　　HostedHttpRouteCollection中的GetVirtualPath方法，其实际调用的是内部封装的ASP.NET路由的全局路由表（RouteCollection类型）的同名方法，请参考前边注释，或参考ASP.NET路由部分。

五、如何将请求转出到ASP.NET Web API 的核心消息处理管道

　　从前边介绍可知道，我们默认指定了一个IRouteHandler为HttpControllerRouteHandler，其返回一个HttpControllerHandler类型的IHttpHandler,其封装了消息处理管道的第一个消息处理器HttpServer,在其ProcessRequestAsync方法中，会触发其执行，来启动ASP.NET Web API 消息处理管道。