Ignore ( )
//如果RouteExistingFiles是默认的false，则任何文件都可以通过请求该文件的物理地址从而得到这个文件
//如果RouteExistingFiles被手动设为true，那么任何文件都不再可以通过请求该文件的物理地址得到文件
//所以在RouteExistingFiles为true的情况下，如果我们想增加一些例外，比如你不希望css或js文件的请求需要通过路由地址访问，
//那么此时才有使用Ignore()方法的必要。
//注意，Ignore(）方法必须放在路由注册的前面，否则无效
//示例：
routes.RouteExistingFiles = true; //请求的任何文件必须使用路由地址访问
routes.Ignore ( "{resource}.css/{*pathInfo}" ); //指示css文件不必通过路由地址访问
 
IgnoreRoute ( )
//与Ignore()方法等同
 
MapPageRoute ( )
//添加一个路由，将Url地址映射为与路由模板匹配的路由地址，比如将一个aspx页面地址映射为与路由模板匹配的路由地址，这样你可以通过路由地址对default.aspx进行访问。
//示例：
RouteTable.Routes.MapPageRoute ( "" , "employees/{name}/{id}/{*other}" , "~/Default.aspx" , true , defaults );
//有了以上的针对具体某一个页面（default.aspx）的路由映射，现在可以直接在浏览器输入http://localhost/employees/sam/1001访问到default.aspx
 
MapRoute ( )
//RouteCollectionExtentions为RouteCollection定义的扩展方法，此方法需要引用System.Web.Mvc程序集。
//用于在ASP.NET MVC框架下添加一个路由，区别于MapPageRoute ( )方法
//此方法并非将某一页面的物理地址映射为一个与路由模板匹配的路由地址，它是定义了一个与任何页面进行匹配的路由模板，这个模板必须具有Contrller和Action变量。
//以下使用MapRoute ( )方法添加了一个路由
//注意，MapRoute()方法的Defaults、Constraint参数不再是RouteValueDictionary，而是object，这是为了编程的便利性，最终它们还是会被路由机制自动转化为RouteValueDictionary
//示例：注册一个路由
routes.MapRoute (
    name: "Default" ,
    url: "{controller}/{action}/{id}" ,
    defaults: new { controller = "Home" , action = "Index" , id = UrlParameter.Optional }
);

//当请求的路由地址被服务端接收后，服务端将在全局路由范围内查找匹配的路由模板
//假设在另一个项目或不同命名空间下存在同名的Controller，那么路由机制如何确定应将请求路由到哪个Controller中呢？
//通过指定namespaces可以使路由查找机制优先考虑使用namespaces所指定的Controller
routes.MapRoute (
    name: "Default" ,
    url: "{controller}/{action}/{id}" ,
    namespaces: new string [ ] { "My.Controllers" } ,  //优先使用My.Controllers命名空间下的Controller
    defaults: new { controller = "Home" , action = "Index" , id = UrlParameter.Optional }
);

GetVirtualPath ( RequestContext requestContext，RouteValueDictionary values )
//遍历全局路由列表，查找与values存储的路由变量完全匹配的路由
//如果匹配成功则返回一个VirtualPathData对象，否则返回null。通过VirtualPathData.VirtualPath可以获取到匹配成功后的Url
//示例：在某个页面中：
string employeeID = RouteData.Values [ "id" ] as string;
System.Web.Routing.RequestContext context = new System.Web.Routing.RequestContext ( );
context.HttpContext = new HttpContextWrapper ( HttpContext.Current );
context.RouteData = RouteData;
string s = RouteData.Route.GetVirtualPath ( context , RouteData.Values ).VirtualPath; //return like：/employees/sam/1001

GetVirtualPath ( RequestContext requestContext，RouteValueDictionary values , string RouteName )
//根据参数指定的路由名称找到该路由，将values存储的路由变量与该路由的路由模板进行匹配
//如果匹配成功则返回一个VirtualPathData对象，否则返回null。通过VirtualPathData.VirtualPath可以获取到匹配成功后的路由地址
 
GetRouteData(RequestContext httpContext);
//此方法将从路由表中查找与当前请求的Url匹配的路由
//如果请求的Url成功匹配了路由模板则返回与当前请求相关的、存储了路由信息的RouteData实例
//如果匹配是失败的，则返回null
//示例：手动创建一个HttpContextBase，通过代码来模拟一次客户端的请求以便获得RouteData
HttpRequest request = new HttpRequest ( "/Home/Index" , "http://localhost:53326/Home/Index" , null );
HttpResponse response = new HttpResponse ( new System.IO.StringWriter ( ) );
HttpContext context = new HttpContext ( request , response );
HttpContextBase contextWraper = new HttpContextWrapper ( context );          
routeData =RouteTable.Routes.GetRouteData ( contextWraper );
 
RouteExistingFiles
//如果将此属性设为true，则所有Url请求都将强制路由匹配。默认false，也即在默认情况下，Url地址的模式可以是某个文件地址的模式也可以是路由模板的模式
//比如假设现在请求的是aspx页面，在浏览器直接输入此页面的地址：http://localhost/default.aspx，因为默认情况下RouteExistingFiles是false，所以对这个页面的直接请求并不会进入路由匹配。

Route
//获取路由对象，返回一个RouteBase

Values
//一个RouteValueDictionary的泛型字典集合，存储了路由变量的默认值。Key是路由变量的名称，Value是变量的值。
//这是在RouteCollection的MapRoute方法中通过defaults参数配置的对象
//存储的是模板变量的默认值
//请求的Url如果与路由模板匹配成功则此字典存储的变量默认值会被替换为Url中的与Key对应的变量值
//如果Key不存在则会抛出异常
//如果要获取查询字符串则依然是使用Request["查询字符变量"]

DataTokens
//一个RouteValueDictionary的泛型字典集合，存储了路由的命名空间
//通过RouteData.DataTokens["Namespaces"]或Route.DataTokens["Namespaces"]可以获取路由所在的命名空间
//如果注册非区域路由时没有在MapRoute中指定namespaces，那么RouteData.DataTokens["Namespaces"]或Route.DataTokens["Namespaces"]都==null
//如果在注册区域路由时没有在MapRoute中指定namespaces，那么路由机制会默认将区域类的命名空间的字符表示拼接一个“.*”的字符作为后缀存储在DataTokens["Namespaces"]中
//如：RouteData.DataTokens["Namespaces"]= Mvc.Areas.FirstArea.*

RouteHandler
//一个实现了IRouteHandler接口的Http处理程序，每一个成功匹配了路由模板的Url请求都由这个Http处理程序进行处理，这个处理程序默认是MvcRouteHandler
//该对象提供接口方法GetHttpHandler()，该方法可以返回一个用于处理当前路由请求的处理程序，此属性用于设置或获取可处理当前路由请求的IRouteHandler对象
//当然，开发人员可以自定义HttpHandler处理程序，以便可以处理特殊的Url请求，详细参看：ASP.NET MVC - ASP.NET请求处理机制浅析

GetRequiredString(string valueName)
//获取segment变量的值
string controllerName = requestContext.RouteData.GetRequiredString( "controller" );

object obj = new { controller = "default" ,action="index"};
RouteValueDictionary routeValue = new RouteValueDictionary ( obj );
var controllerName= routeValue [ "controller" ];
var actionName = routeValue [ "action" ];
//或
RouteValueDictionary routeValue2= new RouteValueDictionary
{
    { "controller","default" },
    { "action","index" }
}

Route
//获取路由对象

VirtualPath
//获取已经成功匹配路由模板的Url，如：employee/3001

HttpContext
//获取一个HttpContextBase类型的表示当前Http请求的上下文

RouteData
//当前的路由信息

//在MapRoute方法的源代码中可以看到如下信息：
//MapRoute方法是RouteCollectionExtentions类为RouteCollection定义的扩展方法
public static Route MapRoute( this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces )
{
    //创建路由对象
    //同时创建一个MvcRouteHandler
    //而在Route的构造函数中源码中，将MvcRouteHandler对象绑定在了Route的RoutData上

    //MvcRouteHandler对象是用来创建ControllerBuilder对象（此对象会根据当前路由数据中的控制器名称创建控制器）和MvcHandler对象（此对象会处理当前的Http路由请求）
    Route route = new Route( url, new MvcRouteHandler( ) )
    {
        Defaults = new RouteValueDictionary( defaults ),
        Constraints = new RouteValueDictionary( constraints ),
        DataTokens = new RouteValueDictionary( )
    };
    return route;
}

Url: "employee / { controller } / { action } / { id }"

defaults: new { controller = "Home" , action = "Index" }
//如果请求的Url没有提供controller变量的值和action变量的值则使用默认值进行填充

public class FirstAreaAreaRegistration : AreaRegistration 
{
    public override string AreaName 
    {
        get => "FirstArea";
    }

public override void RegisterArea(AreaRegistrationContext context) 
    {
        context.MapRoute( //在当前区域下注册路由
            name:"FirstArea_default",
            url:"FirstArea/{controller}/{action}/{id}",
            defaults:new { action = "Index", id = UrlParameter.Optional }
        );
    }
}

//HttpRuntime.ProcessRequestNoDemand的部分源码

//此方法的作用：将Http请求报文对象添加到Http请求队列中
internal static void ProcessRequestNoDemand( HttpWorkerRequest wr )
{
    //RequestQueue是存储IsapiWorkerRequest的队列集合
    //获取Http请求报文的队列集合
    RequestQueue queue = _theRuntime._requestQueue;
    //更新Http请求报文计数器，这将当前的Http请求报文添加到了集合中（个人臆测）
    wr.UpdateInitialCounters( );
    if (queue != null)
    {
        //再从队列中获取当前的Http请求报文
        wr = queue.GetRequestToExecute( wr );
    }
    //ProcessRequestNow方法内部会将IsapiWorkerRequest参数传递给ProcessRequestInternal方法
    ProcessRequestNow( wr );
}

//HttpRuntime.ProcessRequestInternal的部分源码

//此方法的作用：根据Http请求的报文创建HttpContext、HttpContext.Response、HttpContext.Request对象、执行每一个注册好的Http请求的管道事件
private void ProcessRequestInternal( HttpWorkerRequest wr )
{
    HttpContext context;
    //根据IsapiWorkerRequest创建HttpContext对象
    //而在HttpContext的构造函数中会创建出Request和Response的实例
    try { context = new HttpContext( wr, false ); }
    catch
    {
        try
        {
            //400错误，请求无效
            wr.SendStatus( 400, "Bad Request" );
            //将错误信息输出
            wr.SendKnownResponseHeader( 12, "text/html; charset=utf-8" );
            byte[] data = Encoding.ASCII.GetBytes( "<html><body>Bad Request</body></html>" );
            wr.SendResponseFromMemory( data, data.Length );
            wr.FlushResponse( true );
            wr.EndOfRequest( );
            return;
        }
    }

    //GetApplicationInstance方法内部会调用GetNormalApplicationInstance方法创建HttpApplication

   //HttpApplication创建完成，再创建HttpModule、发布管道事件

    //以上全部完成之后，再根据当前请求的扩展名获取一个对应的Http处理程序（HttpHandler），扩展名所对应的HttpHandler注册在web.config中
    IHttpHandler applicationInstance = HttpApplicationFactory.GetApplicationInstance( context );

if (applicationInstance is IHttpAsyncHandler)
    {

        IHttpAsyncHandler handler2 = (IHttpAsyncHandler) applicationInstance;

        context.AsyncAppHandler = handler2;

        handler2.BeginProcessRequest(context, this._handlerCompletionCallback, context);

        //HttpHandler异步处理请求
        handler2.BeginProcessRequest( context, this._handlerCompletionCallback, context );
    }

   else

   {

       //HttpHandler同步处理请求

       applicationInstance.ProcessRequest(context);

       this.FinishRequest(context.WorkerRequest, context, null);

   }
}

//HttpApplicationFactory.GetNormalApplicationInstance的部分源码
//此方法的作用：创建HttpApplication对象

//此方法内部维护着一个HttpApplication池，从池中取出一个闲置状态的HttpApplication或重新创建一个HttpApplication来处理Http请求
private HttpApplication GetNormalApplicationInstance( HttpContext context )
{
    HttpContext state = null;
    //如果HttpApplication池存在处于闲置状态的HttpApplication则取出一个用于处理请求
    if (this._numFreeAppInstances > 0)
    {
        state = (HttpApplication)this._freeList.Pop( );
        //更新HttpApplication计数器
        this._numFreeAppInstances--;
    }
    //如果池中没有闲置的HttpApplication，则重新创建一个HttpApplication
    else
    {
        state = (HttpApplication)HttpRuntime.CreateNonPublicInstance( this._theApplicationType );
    }
    //InitInternal方法内部会调用InitModules方法
    state.InitInternal( context, this._state, this._eventHandlerMethods );
    return state;
}

//HttpApplicationFactory.InitModules的部分源码

//此方法的作用：初始化Http模块（HttpModule）、发布管道事件
private void InitModules( )
{
    //读取注册在Web.config配置文件中的所有HttpModule节信息
    HttpModuleCollection modules = RuntimeConfig.GetAppConfig( ).HttpModules.CreateModules( );
    //HttpModule集合作为HttpApplicationFactory._moduleCollection的成员被使用
    this._moduleCollection = modules;
    //初始化所有HttpModule对象
    this.InitModulesCommon( );
    //发布处理Http请求的管道事件，当请求进入HttpApplication管道后就会逐个触发管道事件

    //而HttpModule因为订阅了管道事件，所以必然会得到执行，HttpHandler则在OnPostResolveRequestCache事件发生之后得到执行
    this._stepManager.BuildSteps( this._resumeStepsWaitCallback );
}

BeginRequest
//开始处理请求时触发
AuthenticateRequest
//正在获取用户的身份标识时触发
PostAuthenticateRequest
//已建立用户的身份标识后触发
AuthorizeRequest
//正在从Cookie中获取用户的身份标识，以便验证该用户是否具有登录权限时触发
PostAuthorizeRequest
//验证已经通过后触发
OnResolveRequestCache
//正在获取页面的缓存信息时触发
PostResolveRequestCache
//已获取页面的缓存信息后触发
PostMapRequestHandler
//创建HttpHandle处理程序实例之后触发
AcquireRequestState
//取得Session时触发
PostAcquireRequestState
//取得Session之后触发
PreRequestHandlerExecute
//执行HttpHandle处理程序之前触发
PostRequestHandlerExecute
//执行完HttpHandle处理程序之后触发
ReleaseRequestState
//正在释放请求状态时触发
PostReleaseRequestState
//释放请求状态完成后触发
UpdateRequestCache
//更新缓存时触发
PostUpdateRequestCache
//更新缓存后触发
LogRequest
//正在将请求写入日志时触发
PostLogRequest
//已将请求写入日志后触发
Error
//处理请求期间发生任何错误时触发
EndRequest
//请求已经走完所有的Http模块和Http处理程序之后触发

Application
//应用程序的全局变量
Context
//返回一个HttpContext，HttpContext表示HTTP请求的上下文对象，它作为HttpApplication的Context 属性被存取。
Modules
//HttpModule模块集合
Request
//Http请求的参数值的对象
Response
//输出数据的对象
Server
//服务端信息对象
Session
//会话对象
User
//身份认证对象

<configuration>
     <system.web>
          <httpModules>
               <!--name：处理模块的类名，type：命名空间,所在程序集-->
               <add name="ApplicationInsightsWebTracking" type="Microsoft.ApplicationInsights.Web.ApplicationInsightsHttpModule, Microsoft.AI.Web" />
          </httpModules>
          <httpHandlers>
               <!--name：处理程序的类名，type：命名空间,所在程序集-->
               <add verb="*" path=".config" type="System.Web.HttpForbiddenHandler"/>
               <add verb="*" path=".aspx" type="System.Web.UI.PageHandlerFactory"/>
          </httpHandlers>
     </system.web>
</configuration>

<configuration>
     <system.webServer>
          <!--name：处理模块的类名，type：命名空间,所在程序集-->
          <add name="ApplicationInsightsWebTracking" type="Microsoft.ApplicationInsights.Web.ApplicationInsightsHttpModule, Microsoft.AI.Web" />
          </modules>
          <handlers>
               <!--name：处理程序的类名，type：命名空间,所在程序集-->
               <add verb="*" path=".config" type="System.Web.HttpForbiddenHandler"/>
               <add verb="*" path=".aspx" type="System.Web.UI.PageHandlerFactory"/>
          </handlers>
     </system.webServer>
</configuration>

using System.Diagnostics;

namespace Users.Infrastructure
{
    public class MessageModule : IHttpModule
    {
        public static List<string> msgList = new List<string>( );
        private Stopwatch stopwatch = new Stopwatch( );
        public void Dispose( ) { }

public void Init( HttpApplication context )
        {
            context.BeginRequest += new EventHandler( OnBeginRequest );
            context.AuthenticateRequest += new EventHandler( OnAuthenticateRequest );
            context.PostAuthenticateRequest += new EventHandler( OnPostAuthenticateRequest );
            context.AuthorizeRequest += new EventHandler( OnAuthorizeRequest );
            context.PostAuthorizeRequest += new EventHandler( OnPostAuthorizeRequest );
            context.ResolveRequestCache += new EventHandler( OnResolveRequestCache );
            context.PostResolveRequestCache += new EventHandler( OnPostResolveRequestCache );
            context.PostMapRequestHandler += new EventHandler( OnPostMapRequestHandler );
            context.PreRequestHandlerExecute += new EventHandler( OnPreRequestHandlerExecute );
            context.PostRequestHandlerExecute += new EventHandler( OnPostRequestHandlerExecute );
            context.AcquireRequestState += new EventHandler( OnAcquireRequestState );
            context.PostAcquireRequestState += new EventHandler( OnPostAcquireRequestState );
            context.ReleaseRequestState += new EventHandler( OnReleaseRequestState );
            context.PostReleaseRequestState += new EventHandler( OnPostReleaseRequestState );
            context.UpdateRequestCache += new EventHandler( OnUpdateRequestCache );
            context.PostUpdateRequestCache += new EventHandler( OnPostUpdateRequestCache );
            context.LogRequest += new EventHandler( OnLogRequest );
            context.PostLogRequest += new EventHandler( OnPostLogRequest );
            context.Error += new EventHandler( OnError );
            context.EndRequest += new EventHandler( OnEndRequest );            
        }

public void OnBeginRequest( object sender, EventArgs e )
        {
            stopwatch.Start( );
            msgList.Add( $"BeginRequest: 开始处理请求时触发……" );
        }

public void OnAuthenticateRequest( object sender, EventArgs e )
        {
            msgList.Add( $"AuthenticateRequest: 正在获取用户的身份标识时触发……" );
        }

public void OnPostAuthenticateRequest( object sender, EventArgs e )
        {
            msgList.Add( $"PostAuthenticateRequest: 已建立用户的身份标识后触发…………" );
        }

public void OnAuthorizeRequest( object sender, EventArgs e )
        {
            msgList.Add( $"AunthorizeRequest : 正在从Cookie中获取用户的身份标识，以便验证该用户是否具有登录权限时触发…………" );
        }

public void OnPostAuthorizeRequest( object sender, EventArgs e )
        {
            msgList.Add( $"PostAuthorizeRequest : 验证已经通过后触发…………" );
        }

public void OnResolveRequestCache( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 正在获取页面的缓存信息时触发…………" );
        }

public void OnPostResolveRequestCache( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 已获取页面的缓存信息后触发…………" );
        }

public void OnPostMapRequestHandler( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 创建HttpHandle处理程序实例之后触发…………" );
        }

public void OnAcquireRequestState( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 取得Session时触发…………" );
        }

public void OnPostAcquireRequestState( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 取得Session之后触发…………" );
        }

//此事件处理完毕后，视图页面就会发送给客户端
        public void OnPreRequestHandlerExecute( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 执行HttpHandle处理程序之前触发…………" );
            msgList.Add( $"从请求发起到呈现视图的总耗时：{stopwatch.ElapsedMilliseconds}毫秒" );
        }

//所以从这个事件起，纵然服务端继续运行以下事件，但客户端不会看到以下事件的输出结果
        public void OnPostRequestHandlerExecute( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 执行完HttpHandle处理程序之后触发…………" );
        }

public void OnReleaseRequestState( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 正在释放请求状态时触发…………" );
        }

public void OnPostReleaseRequestState( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 释放请求状态完成后触发…………" );
        }

public void OnUpdateRequestCache( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 更新缓存时触发…………" );
        }

public void OnPostUpdateRequestCache( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 更新缓存后触发…………" );
        }

public void OnLogRequest( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 正在将请求写入日志时触发…………" );
        }

public void OnPostLogRequest( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 已将请求写入日志后触发…………" );
        }

public void OnError( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 处理请求发生错误时触发…………" );
        }

public void OnEndRequest( object sender, EventArgs e )
        {
            msgList.Add( $"ResolveRequestCache : 请求已经走完所有的Http模块和Http处理程序之后触发…………" );
            msgList.Add( $"从请求发起到服务端释放资源总耗时：{stopwatch.ElapsedMilliseconds}毫秒" );
            stopwatch.Stop( );
        }
    }
}

public class UrlRoutingModule : IHttpModule
{
    public void Dispose( ) { }
    public void Init( HttpApplication context )
    {
        //PostResolveRequestCache事件发生时将由OnApplicationPostResolveRequestCache方法进行处理
        context.PostResolveRequestCache += new EventHandler( OnApplicationPostResolveRequestCache );
    }

public void OnApplicationPostResolveRequestCache( object sender, EventArgs e )
    {
        //获取Http上下文对象
        HttpContextBase context = new HttpContextWrapper( ((HttpApplication)sender).Context );
        //调用PostResolveRequestCache方法
        PostResolveRequestCache( context );
    }

public void PostResolveRequestCache( HttpContextBase context )
    {

　　　　  //创建一个ControllerBuilder对象存入静态Current属性中，这样可以使该对象成为内存中的全局唯一对象，可避免每次请求到达都重复创建相同的ControllerBuilder

　　　　  //ControllerBuilder用于创建控制器工厂，而控制器工厂用于实例化一个具体的与当前路由数据中的控制器名称对应的控制器

　　　　  ControllerBuilder.Current = new ControllerBuilder( );

        //将Http上下文对象作为参数传递给RouteTable.Routes.GetRouteData方法
        //该方法将从Http上下文对象中取出请求的Url信息
        //然后从路由表中查找与当前请求的Url相匹配的路由数据对象（RouteData）
        RouteData routeData = RouteTable.Routes.GetRouteData( context );
        if (routeData != null)
        {
            //每一个成功匹配了路由模板的Url请求都关联了一个MvcRouteHandler 
            //MvcRouteHandler通过RouteData.RouteHandler可以获取
            IRouteHandler routeHandler = routeData.RouteHandler;

if (!(routeHandler is StopRoutingHandler))
            {

                //MvcRouteHandler.GetHttpHandler方法会创建一个MvcHandler和一个ControllerBuilder对象

                IHttpHandler httpHandler = routeHandler.GetHttpHandler( requestContext );
                //把Http处理程序（MvcHandler）注入HttpApplication的处理管道中
                context.RemapHandler( httpHandler );
            }
        }
    }
}

namespace MVC.Controllers
{
    public class MyRoutingModule : IHttpModule
    {
        public RouteCollection RouteCollection { get => RouteTable.Routes; }
        public void Dispose ( ) { }

public void Init ( HttpApplication application )
        {
            application.PostResolveRequestCache += OnApplicationPostResolveRequestCache;
        }

private void OnApplicationPostResolveRequestCache ( object sender , EventArgs e )
        {
            HttpContext contex = ( sender as HttpApplication ).Context;
            HttpContextBase contextWrapper = new HttpContextWrapper ( contex );
            RouteData routeData = RouteCollection.GetRouteData ( contextWrapper );

RequestContext requestContext = new RequestContext
            {
                HttpContext = contextWrapper ,
                RouteData = routeData
            };
            routeData.RouteHandler = new MyRouteHandler ( );
            IHttpHandler handler = routeData.RouteHandler.GetHttpHandler ( requestContext ); 
            contex.RemapHandler ( handler ); 
        }
    }
    public class MyRouteHandler : IRouteHandler
    {
        public IHttpHandler GetHttpHandler ( RequestContext requestContext )
        {
            return new MyHttpHandler ( );
        }

//嵌套类
        private class MyHttpHandler : IHttpHandler
        {
            public bool IsReusable => throw new NotImplementedException ( );

public void ProcessRequest ( HttpContext context )
            {
                context.Response.Write ( "这是自定义的路由处理程序" );
            }
        }
    }
}

system.webServer>
    <modules>
       <add name="MyRoutingModule" type="MVC.Controllers.MyRoutingModule"/>
    </modules>
</system.webServer