ASP.NET Web API 框架研究 ASP.NET 路由

  ASP.NET Web API 如果采用Web Host方式来寄宿,在请求进入Web API 消息处理管道之前,就会用ASP.NET 自身的路由系统根据注册的路由表,解析出当前请求的HttpController和Action的名称,以及与目标Action方法某个参数进行绑定的路由变量。

  ASP.NET路由系统包括两方面应用:

  • 注册路由映射,即注册路由模板和物理文件的匹配关系,实现请求URL地址和处理请求的物理地址的分离,可以提高请求URL可读性,SEO优化,灵活性,即请求URL和处理请求的物理文件的变化互不影响
  • URL生成,根据注册的路由规则生成相应URL,使用这种URL,刚好利用了路由注册的灵活性,可以使原来生成的URL不中断,只需要修改路由配置的处理文件。

一、涉及的类及源码分析

  涉及的主要类型都在System.Web.Routing中,类及主要成员和相互关系如下图:

  ASP.NET Web API 框架研究  ASP.NET 路由

1、RouteBase

  public abstract class RouteBase
  {
    private bool _routeExistingFiles = true;
    //根据路由模板与请求的URL进行匹配,如果成功返回RouteData,否则返回NULL
    public abstract RouteData GetRouteData(HttpContextBase httpContext);
    //采用指定的路由变量列表(包含名称和值)与URL路由模板进行匹配,若匹配成功,返回完整URL,否则返回NULL
    public abstract VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values);
    //表示是否对现有的物理文件实施路由,默认值为true,即通过地址“/employees/hr/index.aspx” 是访问不到 Index.aspx页面
    //但是有时候我们希望以物理文件路径方式来访问对应的物理文件,可以设置该值为false,就可以访问到Index.aspx页面
    public bool RouteExistingFiles
    {
      get
      {
        return this._routeExistingFiles;
      }
      set
      {
        this._routeExistingFiles = value;
      }
    }
  }

2、Route

  RouteBase唯一子类,基于路由模板模式的路由匹配规则就定义在其中,向全局路由表中添加的就是一个Route对象。

  public class Route : RouteBase
  {
    private const string HttpMethodParameterName = "httpMethod";
    private string _url;
    private ParsedRoute _parsedRoute;

    //构造函数,前边省略N个重载
    public Route(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler routeHandler)
    {
      this.Url = url;
      this.Defaults = defaults;
      this.Constraints = constraints;
      this.DataTokens = dataTokens;
      this.RouteHandler = routeHandler;
    }

    //为路由模板中的变量以正则表达式的形武设定一些约束条件,Key为变量名,Value为正则表达式
    //如果有定义,匹配也要满足该约束
    public RouteValueDictionary Constraints { get; set; }
    //存储额外的变量值
    public RouteValueDictionary DataTokens { get; set; }
    //路由变量默认值,也不一定要定义在路由模板中
    public RouteValueDictionary Defaults { get; set; }

    public IRouteHandler RouteHandler { get; set; }

    //路由模板,如/weather/{areacode}/{days},请求的URL就是跟该模板进行匹配,/分割成多个段,每个段又分变量(areacode,days)和字面量(weather)
    //匹配的两个条件,段数和路由模板相同,以及对应文本段内容也要相同,注,URL大小写不敏感
    public string Url
    {
      get
      {
        return this._url ?? string.Empty;
      }
      set
      {
        this._parsedRoute = RouteParser.Parse(value);
        this._url = value;
      }
    }

    //根据路由模板与请求的URL进行匹配,如果成功返回RouteData,否则返回NULL

    public override RouteData GetRouteData(HttpContextBase httpContext)
    {
      RouteValueDictionary values = this._parsedRoute.Match(httpContext.Request.AppRelativeCurrentExecutionFilePath.Substring(2) + httpContext.Request.PathInfo,         this.Defaults);
      if (values == null)
        return (RouteData)null;
      RouteData routeData = new RouteData((RouteBase)this, this.RouteHandler);
      if (!this.ProcessConstraints(httpContext, values, RouteDirection.IncomingRequest))
        return (RouteData)null;
      foreach (KeyValuePair<string, object> keyValuePair in values)
        routeData.Values.Add(keyValuePair.Key, keyValuePair.Value);
      if (this.DataTokens != null)
      {
        foreach (KeyValuePair<string, object> dataToken in this.DataTokens)
        routeData.DataTokens[dataToken.Key] = dataToken.Value;
      }
      return routeData;
    }

    //采用指定的路由变量列表(包含名称和值)与URL路由模板进行匹配,若匹配成功,返回完整URL,否则返回NULL
    public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
    {
      BoundUrl boundUrl = this._parsedRoute.Bind(requestContext.RouteData.Values, values, this.Defaults, this.Constraints);
      if (boundUrl == null)
        return (VirtualPathData)null;
      if (!this.ProcessConstraints(requestContext.HttpContext, boundUrl.Values, RouteDirection.UrlGeneration))
        return (VirtualPathData)null;
      VirtualPathData virtualPathData = new VirtualPathData((RouteBase)this, boundUrl.Url);
      if (this.DataTokens != null)
      {
        foreach (KeyValuePair<string, object> dataToken in this.DataTokens)
          virtualPathData.DataTokens[dataToken.Key] = dataToken.Value;
      }
      return virtualPathData;
    }

    //处理约束
    protected virtual bool ProcessConstraint(HttpContextBase httpContext, object constraint, string parameterName, RouteValueDictionary values, RouteDirection       routeDirection)
    {
      IRouteConstraint routeConstraint = constraint as IRouteConstraint;
      if (routeConstraint != null)
        return routeConstraint.Match(httpContext, this, parameterName, values, routeDirection);
      string str = constraint as string;
      if (str == null)
        throw new InvalidOperationException(string.Format((IFormatProvider)CultureInfo.CurrentUICulture,                             System.Web.SR.GetString("Route_ValidationMustBeStringOrCustomConstraint"), new object[2]
      {
        (object) parameterName,
        (object) this.Url
      }));
      object obj;
      values.TryGetValue(parameterName, out obj);
      return Regex.IsMatch(Convert.ToString(obj, (IFormatProvider)CultureInfo.InvariantCulture), "^(" + str + ")$", RegexOptions.IgnoreCase |               RegexOptions.CultureInvariant);
    }

    private bool ProcessConstraints(HttpContextBase httpContext, RouteValueDictionary values, RouteDirection routeDirection)
    {
      if (this.Constraints != null)
      {
        foreach (KeyValuePair<string, object> constraint in this.Constraints)
        {
          if (!this.ProcessConstraint(httpContext, constraint.Value, constraint.Key, values, routeDirection))
          return false;
        }
      }
      return true;
    }

  }

  另外,RequestContext是对Http请求上下文和路由数据的封装

  public class RequestContext
  {
    public RequestContext()
    {
    }

    public RequestContext(HttpContextBase httpContext, RouteData routeData)
    {
      if (httpContext == null)
        throw new ArgumentNullException(nameof(httpContext));
      if (routeData == null)
        throw new ArgumentNullException(nameof(routeData));
      this.HttpContext = httpContext;
      this.RouteData = routeData;
    }
    //请求上下文
    public virtual HttpContextBase HttpContext { get; set; }
    //路由数据
    public virtual RouteData RouteData { get; set; }
  }

3、RouteData

   RouteBase的GetRouteData方法的返回类型,用于封装解析后路由数据,其用RouteValueDictionary保存路由变量数据,RouteValueDictionary是—个字典,其 Key和 Value分别表示路由变量的名称和值,定义如下:

  public class RouteValueDictionary : IDictionary<string, object>

  {

  }

  public class RouteData
  {
    private RouteValueDictionary _values = new RouteValueDictionary();
    private RouteValueDictionary _dataTokens = new RouteValueDictionary();
    private IRouteHandler _routeHandler;

    public RouteData()
    {
    }

    public RouteData(RouteBase route, IRouteHandler routeHandler)
    {
      this.Route = route;
      this.RouteHandler = routeHandler;
    }

    //是直接附加到Route上的自定义变量。
    public RouteValueDictionary DataTokens
    {
      get
      {
        return this._dataTokens;
      }
    }

    //解析它的 Route对象

    public RouteBase Route { get; set; }

    //提供最 终用 于处理请求的HttpHandIer对象(通过调用其GetHttpHandler方法获取)

    //可以在构造函数中传入,也可以属性赋值
    public IRouteHandler RouteHandler
    {
      get
      {
        return this._routeHandler;
      }
      set
      {
        this._routeHandler = value;
      }
    }

    //其中的路由变量是Route通过对请求URL的解析得到的
    public RouteValueDictionary Values
    {
      get
      {
        return this._values;
      }
    }

    //获取包含某些固定名称的变量值(如controller和action)对应的值
    public string GetRequiredString(string valueName)
    {
      object obj;
      if (this.Values.TryGetValue(valueName, out obj))
      {
        string str = obj as string;
        if (!string.IsNullOrEmpty(str))
          return str;
      }
      //不存在直接抛出异常
      throw new InvalidOperationException(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, System.Web.SR.GetString("RouteData_RequiredValue"), new         object[1]
          {
            (object) valueName
          }));
    }
  }

  

  public interface IRouteHandler
  {
    IHttpHandler GetHttpHandler(RequestContext requestContext);
  }

4、VirtualPathData

  RouteBase的GeVirtualPathData方法的返回类型

  public class VirtualPathData
  {
    private RouteValueDictionary _dataTokens = new RouteValueDictionary();
    private string _virtualPath;

    public VirtualPathData(RouteBase route, string virtualPath)
    {
      this.Route = route;
      this.VirtualPath = virtualPath;
    }

    //来源于附加到 Route的 自定义变量集合
    public RouteValueDictionary DataTokens
    {
      get
      {
        return this._dataTokens;
      }
    }
    //当时解析的路由对象
    public RouteBase Route { get; set; }

    //完整虚拟路径
    public string VirtualPath
    {
      get
      {
        return this._virtualPath ?? string.Empty;
      }
      set
      {
        this._virtualPath = value;
      }
    }
  }

5、RouteTable Routes RouteCollection

  全局路由表,即RouteTable类的静态属性Routes 类型为RouteCollection,通过其中的MapPageRoute方法进行路由映射

  public class RouteTable
  {
    private static RouteCollection _instance = new RouteCollection();

    public static RouteCollection Routes
    {
      get
      {
        return RouteTable._instance;
      }
    }
  }

  RouteCollection 是Route的集合

  主要逻辑:

    RouteCollection的GetRouteData和GetVirtalPath方法会遍历集合中的每个Route对象,并传入给定的参数调用同名方法直到找到一个匹配的Route(返回值不为Null),并返回相应的RouteData和VirtaulPathData对象,如果集合中任何一个Route都不匹配,最终返回NULL

  读写锁的应用:

    RouteCollection这个集合对象不是线程安全的,使用ReaderWriterLockSlim进行线程读写同步,多个线程可以同时读,其他情况都不允许,一个线程写时,其他的线程不能读或写,一个线程在读时候,其他线程只能读,不能写,即多个线程只能读读,不能读写、写写;

    在对集合进行读取或更新时候,会调用GetReadLock和GetWriteLock方法获取读锁或写锁,返回的是内嵌私有类型:ReadLockDispsoabled和WriteLockDispsoabled,他们实现了接口IDispsoabled,是对ReaderWriterLockSlim的读写锁功能的封装。

  public class RouteCollection : Collection<RouteBase>
  {
    private Dictionary<string, RouteBase> _namedMap = new Dictionary<string, RouteBase>((IEqualityComparer<string>)StringComparer.OrdinalIgnoreCase);
    private ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();

    public RouteCollection()
    {
    }

    public bool RouteExistingFiles { get; set; }

    public void Add(string name, RouteBase item)
    {
      //...
      this.Add(item);
      if (!string.IsNullOrEmpty(name))
        this._namedMap[name] = item;
      Route route = item as Route;
      if (route == null || route.RouteHandler == null)
        return;
    }

    //省略N个重载方法
    public Route MapPageRoute(string routeName, string routeUrl, string physicalFile, bool checkPhysicalUrlAccess, RouteValueDictionary defaults, RouteValueDictionary       constraints, RouteValueDictionary dataTokens)
    {
      if (routeUrl == null)
        throw new ArgumentNullException(nameof(routeUrl));
      //新建路由对象,IRouteHandler直接new PageRouteHandler
      Route route = new Route(routeUrl, defaults, constraints, dataTokens, (IRouteHandler)new PageRouteHandler(physicalFile, checkPhysicalUrlAccess));
      //添加进去
      this.Add(routeName, (RouteBase)route);
      return route;
    }

    protected override void ClearItems()
    {
      this._namedMap.Clear();
      base.ClearItems();
    }

    public IDisposable GetReadLock()
    {
      this._rwLock.EnterReadLock();
      return (IDisposable)new System.Web.Routing.RouteCollection.ReadLockDisposable(this._rwLock);
    }

    private RequestContext GetRequestContext(RequestContext requestContext)
    {
      if (requestContext != null)
        return requestContext;
      HttpContext current = HttpContext.Current;
      if (current == null)
        throw new InvalidOperationException(System.Web.SR.GetString("RouteCollection_RequiresContext"));
      return new RequestContext((HttpContextBase)new HttpContextWrapper(current), new RouteData());
    }

    private bool IsRouteToExistingFile(HttpContextBase httpContext)
    {
      string executionFilePath = httpContext.Request.AppRelativeCurrentExecutionFilePath;
      if (!(executionFilePath != "~/") || this.VPP == null)
        return false;
      if (!this.VPP.FileExists(executionFilePath))
        return this.VPP.DirectoryExists(executionFilePath);
      return true;
    }

    public RouteData GetRouteData(HttpContextBase httpContext)
    {
      ...
      using (this.GetReadLock())
      {
        //遍历集合中所有RouteBase,并调用其GetRouteData方法,找到了就马上返回
        foreach (RouteBase routeBase in (Collection<RouteBase>)this)
        {
          RouteData routeData = routeBase.GetRouteData(httpContext);
          if (routeData != null)
          {
            if (!routeBase.RouteExistingFiles)
            {
              if (!flag2)
                flag1 = this.IsRouteToExistingFile(httpContext);
              if (flag1)
                return (RouteData)null;
            }
            return routeData;
          }
        }
      }
      return (RouteData)null;
    }

    public VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
    {
      requestContext = this.GetRequestContext(requestContext);
      using (this.GetReadLock())
      {
        //遍历集合中所有RouteBase,并调用其GetVirtualPath方法,找到了就马上返回
        foreach (RouteBase routeBase in (Collection<RouteBase>)this)
        {
          VirtualPathData virtualPath = routeBase.GetVirtualPath(requestContext, values);
          if (virtualPath != null)
          {
            virtualPath.VirtualPath = this.NormalizeVirtualPath(requestContext, virtualPath.VirtualPath);
            return virtualPath;
          }
        }
      }
      return (VirtualPathData)null;
    }

    public VirtualPathData GetVirtualPath(RequestContext requestContext, string name, RouteValueDictionary values)
    {
      requestContext = this.GetRequestContext(requestContext);
      if (string.IsNullOrEmpty(name))
        return this.GetVirtualPath(requestContext, values);
      RouteBase routeBase;
      bool flag;
      using (this.GetReadLock())
        flag = this._namedMap.TryGetValue(name, out routeBase);
      if (flag)
      {
        VirtualPathData virtualPath = routeBase.GetVirtualPath(requestContext, values);
        if (virtualPath == null)
          return (VirtualPathData)null;
        virtualPath.VirtualPath = this.NormalizeVirtualPath(requestContext, virtualPath.VirtualPath);
        return virtualPath;
      }
      throw new ArgumentException(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, System.Web.SR.GetString("RouteCollection_NameNotFound"), new         object[1]
        {
          (object) name
        }), nameof(name));
     }

    public IDisposable GetWriteLock()
    {
      this._rwLock.EnterWriteLock();
      return (IDisposable)new System.Web.Routing.RouteCollection.WriteLockDisposable(this._rwLock);
    }

    //忽略路由
    public void Ignore(string url)
    {
      this.Ignore(url, (object)null);
    }

    public void Ignore(string url, object constraints)
    {
      if (url == null)
        throw new ArgumentNullException(nameof(url));
      System.Web.Routing.RouteCollection.IgnoreRouteInternal ignoreRouteInternal = new System.Web.Routing.RouteCollection.IgnoreRouteInternal(url);
      RouteValueDictionary routeValueDictionary = new RouteValueDictionary(constraints);
      ignoreRouteInternal.Constraints = routeValueDictionary;
      this.Add((RouteBase)ignoreRouteInternal);
    }

    protected override void InsertItem(int index, RouteBase item)
    {
      if (item == null)
        throw new ArgumentNullException(nameof(item));
      if (this.Contains(item))
        throw new ArgumentException(string.Format((IFormatProvider)CultureInfo.CurrentCulture, System.Web.SR.GetString("RouteCollection_DuplicateEntry"), new           object[0]), nameof(item));
      base.InsertItem(index, item);
    }

    protected override void RemoveItem(int index)
    {
      this.RemoveRouteName(index);
      base.RemoveItem(index);
    }

    private void RemoveRouteName(int index)
    {
      RouteBase routeBase = this[index];
      foreach (KeyValuePair<string, RouteBase> named in this._namedMap)
      {
        if (named.Value == routeBase)
        {
          this._namedMap.Remove(named.Key);
          break;
        }
      }
    }

    protected override void SetItem(int index, RouteBase item)
    {
      if (item == null)
        throw new ArgumentNullException(nameof(item));
      if (this.Contains(item))
        throw new ArgumentException(string.Format((IFormatProvider)CultureInfo.CurrentCulture, System.Web.SR.GetString("RouteCollection_DuplicateEntry"), new           object[0]), nameof(item));
      this.RemoveRouteName(index);
      base.SetItem(index, item);
    }

    private class ReadLockDisposable : IDisposable
    {
      private ReaderWriterLockSlim _rwLock;

      public ReadLockDisposable(ReaderWriterLockSlim rwLock)
      {
        this._rwLock = rwLock;
      }

      void IDisposable.Dispose()
      {
        this._rwLock.ExitReadLock();
      }
    }

    private class WriteLockDisposable : IDisposable
    {
      private ReaderWriterLockSlim _rwLock;

      public WriteLockDisposable(ReaderWriterLockSlim rwLock)
      {
        this._rwLock = rwLock;
      }

      void IDisposable.Dispose()
      {
        this._rwLock.ExitWriteLock();
      }
    }

    private sealed class IgnoreRouteInternal : Route
    {
      public IgnoreRouteInternal(string url)
        : base(url, (IRouteHandler)new StopRoutingHandler())
      {
      }

      public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary routeValues)
      {
        return (VirtualPathData)null;
      }
    }
  }

6、IRouteConstraint

  除了用正则表达式对某个变量进行约束外,还可以用一个实现了IRouteConstraint接口的对象对整个请求进行约束

  public interface IRouteConstraint
  {
    bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection);
  }

二、注册路由映射

1、基本使用MapPageRoute方法

  注册路由映射核心是在全局路由表RouteTable.Routes里添加一个Route对象,通过调用路由表的MapPageRoute方法,该方法可以传递各种相关参数,如前一节的源码

  public Route MapPageRoute(string routeName, string routeUrl, string physicalFile, bool checkPhysicalUrlAccess, RouteValueDictionary defaults, RouteValueDictionary       constraints, RouteValueDictionary dataTokens)

  可以指定路由名称routeName,模板routeUrl,对应处理的物理文件physicalFile,是否核对路由目标地址的URL授权,默认值defaults,约束constraints,附加到 Route的 自定义变量集合dataTokens

  如我们可以按下边传递参数:   

    " }, { "days", 2 }};

    //约束,正则表达式
    var constaints = new RouteValueDictionary { { "areacode", @"0\d{2,3}" }, { "days", @"[1-3]" } };

    //对变量默认值的说明
    var dataTokens = new RouteValueDictionary { { "defaultCity", "BeiJing" }, { "defaultDays", 2 } };

    RouteTable.Routes.MapPageRoute("default", "{areacode}/{days}","~/weather.aspx", false, defaults, constaints, dataTokens);

  由上边源码可知,会建立如下Route对象

    Route route = new Route(routeUrl, defaults, constraints, dataTokens, (IRouteHandler)new PageRouteHandler(physicalFile, checkPhysicalUrlAccess));

  IRouteHandler是new PageRouteHandler(physicalFile, checkPhysicalUrlAccess)

2、自定义约束IRouteConstraint

  接下来,我们用继承自IRouteConstraint约束类来限制请求允许的方法   

    public class HttpMethodConstraint : IRouteConstraint
    {
      public HttpMethodConstraint(params string[] allowedMethods);

      public ICollection<string> AllowedMethods { get; }

      protected virtual bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection);
    }

  使用方法:

     { "httpMethod", new HttpMethodConstraint("POST") }

  当然,可以传多个

3、直接路由物理文件(RouteExistingFiles)

  RouteCollection和RouteBase都有属性RouteExistingFiles ,默认值分别为 false和true,要成功匹配路由,要满足两个条件

  两者RouteExistingFiles 都为true,Route 的URL模板和请求URL匹配,否则不会获得RouteData数据。

  如我们按传统方式访问一个物理文件http://myhost:1111/my.aspx,路由配置一样

  RouteTable.Routes.MapPageRoute("default", "{areacode}/{days}","~/my.aspx", false, defaults, constaints, dataTokens);

  my.aspx页面会打印成功匹配后的路由(RouteData)数据,运行结果显示,虽然成功匹配(days由默认值),但是处理页面my.aspx没有显示路由数据。所以要设置

  RouteTable.Routes.RouteExistingFiles = true;

4、注册忽略路由(Ignore)

  IIS7.5以及在集成模式下,所有请求都要进入ASP.NET管道,那么我们要过滤掉一些css和js之类的请求,不对这些请求进行路由,通过全局路由表RouteCollection的Ignore方法,如下语句

  RouteTable.Routes.Ignore("css/{filename}.css/{*pathInfo}");

5、路由注册第二种方式(Add方法)

  RouteTable.Routes.Add(new Route("{areacode}/{days}",defaults, constaints, dataTokens,new PageRouteHandler("~/my.aspx", false ));

三、根据路由规则生成URL

  即使用RouteTable.Routes.GetVirtualPath,通过路由配置生成 URL ,好处是可以更改配置而无需担心在应用程序中创建的URL链接中断,下边是一个使用例子:

  private string GetVirtualPathForRecipe(string recipeName)

  {

    VirtualPathData pathData =

      RouteTable.Routes.GetVirtualPath(
      null,
      "Recipe",
      new RouteValueDictionary { { "Name", recipeName } });

    return pathData.VirtualPath;

  }  

  Recipe是路由名称,路由模板为 (/recipe/{name}) ,new RouteValueDictionary { { "Name", recipeName }是传入的路由变量及其值

  var recipes =
    new RecipeRepository()
      .GetAllRecipeNames()
      .OrderBy(recipeName => recipeName)
      .Select(recipeName =>
        new
        {
          Name = recipeName,
          Url = GetVirtualPathForRecipe(recipeName)
        });

四、如何获取最终处理请求的HttpHandler(UrlRoutingModule)

  HttpHandler是由以下接口获得的

  public interface IRouteHandler
  {
    IHttpHandler GetHttpHandler(RequestContext requestContext);
  }

  从前边源码,可以知道,路由注册时候就指定了PageRouteHandler作为IRouteHandler,其GetHttpHandler方法会返回处理physicalFile的IHttpHandler

  Route route = new Route(routeUrl, defaults, constraints, dataTokens, (IRouteHandler)new PageRouteHandler(physicalFile, checkPhysicalUrlAccess));

  那什么时候让系统知道,处理当前请求是用那个Httphandler呢,利用拦截HttpModule来实现。UrlRoutingModule就是这个请求拦截器。定义如下:

  public class UrlRoutingModule : IHttpModule

  {

    public RouteCollection RouteCollection { get; set; }
    protected void Init(HttpApplication context)

    {
      context.PostResolveRequestCache += new EventHandler(this.OnPostResolveRequestCache);
    }
    void OnPostResolveRequestCache( object o, EventArgs e)

    {
      HttpContext context = ((HttpApplication)sender).Context;
      HttpContextBase contextWrapper = new HttpContextWrapper(context);
      //从当前请求获取路由解析后的数据RouteData
      var routeData = RouteCollection.GetRouteData (contextWrapper);
      //封装RouteData对象和当前HttpRequest对象为requestContext
      var requestContext = new RequestContext (context, routeData);
      //使用当前RouteData对象中的RouteHander属性获取路由处理程序IHttpHander接口
      IHttpHandler httpHandler = routeData.RouteHandler.GetHttpHandler (requestContext );
      context.Request.RequestContext = requestContext ;
      context.RemapHandler (httpHandler);

     }

  }

 
上一篇:[js高手之路] html5 canvas教程 - 绘制七巧板


下一篇:MYSQL免安装版使用说明