【转载】ASP.Net请求处理机制初步探索之旅 - Part 3 管道

谁借莪１个温暖的怀抱￠ 2021-11-05 20:36 278阅读 0赞

开篇：**上一篇我们了解了一个ASP.Net页面请求的核心处理入口，它经历了三个重要的入口，分别是：ISAPIRuntime.ProcessRequest()、HttpRuntime.ProcessRequest()以及HttpApplication.Init()。其中，在HttpApplication的Init()方法中触发了请求处理管道事件的执行，本篇我们就来看看所谓的请求处理管道。**

> **（1）Part 1：[前奏][Link 1]**
> 
> **（2）Part 2：[核心][Link 2]**
> 
> **（3）Part 3：管道**
> 
> **（4）Part 4：[WebForm页面生命周期][WebForm]**
> 
> **（5）Part 5：[MVC页面声命周期][MVC]**

# **一、所谓“请求处理管道”** #

**　　HttpApplication**对象是ASP.NET中处理请求的重要对象，但是，这种类型的对象实例不是由程序员来创建的，而是由**ASP.NET**帮助我们创建的。为了便于扩展处理工作，HttpApplication采用处理管道的方法进行处理，将处理的过程分为多个步骤，每个步骤通过事件的形式暴露给程序员，这些事件按照固定的处理顺序依次触发，程序员通过编写事件处理方法就可以自定义每一个请求的扩展处理过程。

## ①传说中的19个事件 ##

对于**HttpApplication**来说，到ASP.NET 4.0版本，提供了**19**个重要的标准事件，如下图所示：

![051721569687793.jpg][]

在整个请求处理管道中，**HttpContext**上下文被依次传输到各个处理事件中，由不同的处理单元（**HttpModule、HttpHandler、Page**等）进行处理。从这里可以看出，ASP.NET请求处理管道就像是一个大型的**AOP**框架。

## ②HttpModule与HttpHandler ##

在进一步深入了解之前，让我们先来了解一下什么是**HttpModule**和**HttpHandlers**。他们帮助我们在ASP.NET页面处理过程的前后注入自定义的逻辑处理。他们之间主要的差别在于：

*  如果你想要注入的逻辑是基于像'.aspx'，'.html'这样的扩展文件，那么你可以使用**HttpHandler**。换句话说，**HttpHandler**是一个基于处理器的扩展。
 *  ![051739482654839.jpg][]
 *  ***HttpHandler总结：***在ASP.NET WebForm中，无论是**一般处理程序**还是**WebPage**都实现了**IHttpHandler**接口，而ASP.NET MVC中也有**MvcHandler**实现了**IHttpHandler**接口；
 *  如果你想要在ASP.NET管道事件中注入逻辑，那么你可以使用**HttpModule**。也可以说，**HttpModule**是一个基于处理器的事件。
 *  ![051740074374283.jpg][]
 *  ***HttpModule总结：***刚刚我们说到ASP.NET请求处理管道就像是一个大型的**AOP**框架，因此我们可以借助**HttpModule**自定义地注册或移除一些事件逻辑，以完成我们想要的效果。ASP.NET默认实现了针对WebForm和MVC的HttpModule，像ASP.NET MVC中默认使用的是UrlRoutingModule。具体实现方式是：通过改写**Global**文件或自定义一个实现**IHttpModule**接口的类并在Web.config中进行注册。
 *  ![复制代码][Image 1]
    
        <?xml version="1.0"?>
        <configuration>
            <system.web>
                <httpModules>
                    <add name="myHttpModule" type="FirstModule"/>
                </httpModules>
            </system.web>
        </configuration>
    
    ![复制代码][Image 1]
    
    ![复制代码][Image 1]
    
        public class FirstModule : IHttpModule
            {
                public void Dispose()
                {
                    throw new NotImplementedException();
                }
        
                public void Init(HttpApplication context)
                {
                    context.BeginRequest += new EventHandler(context_BeginRequest);
                }
        
                void context_BeginRequest(object sender, EventArgs e)
                {
                    HttpApplication application = sender as HttpApplication;
                    application.Context.Response.Write("第三方过滤器：哇哈哈！");
                }
            }
    
    ![复制代码][Image 1]

## ③19个事件中我们可以做些什么？ ##

一个十分有价值的问题就是在什么事件中我们又可以做些什么？下表就展示了这个问题的答案：

<table> 
 <tbody> 
  <tr> 
   <td><strong>Section</strong></td> 
   <td><strong>Event</strong></td> 
   <td><strong>Description</strong></td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>BeginRequest</td> 
   <td>此事件标志着一个新的请求，它保证在每个请求中都会被触发。</td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>AuthenticateRequest</td> 
   <td>此事件标志ASP.NET运行时准备验证用户。任何身份验证代码都可以在此注入。</td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>AuthorizeRequest</td> 
   <td>此事件标志ASP.NET运行时准备授权用户。任何授权代码都可以在此注入。</td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>ResolveRequest</td> 
   <td>在ASP.NET中我们通常使用OutputCache指令做缓存。在这个事件中，ASP.NET运行时确定是否能够从缓存中加载页面，而不是从头开始生成。任何缓存的具体活动可以被注入这里。</td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>AcquireRequestState</td> 
   <td>此事件标志着ASP.NET运行时准备获得<strong>Session</strong>会话变量。可以对Session变量做任何你想要做的处理。</td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>PreRequestHandlerExecute</td> 
   <td>恰好在ASP.NET 开始执行事件处理程序前发生。可以预处理你想做的事。</td> 
  </tr> 
  <tr> 
   <td>HttpHandler</td> 
   <td>ProcessRequest</td> 
   <td>HttpHandler逻辑被执行。在这个部分我们将为每个页面扩展写需要的逻辑。</td> 
  </tr> 
  <tr> 
   <td>Page</td> 
   <td>Init</td> 
   <td>此事件发生在ASP.NET页面且可以用来：&nbsp;<br>1、动态地创建控件，如果你一定要在运行时创建控件；&nbsp;<br>2、任何初始化设置&nbsp;<br>3、母版页及其设置&nbsp;<br>在这部分中我们没有获得viewstate、postedvalues及已经初始化的控件。</td> 
  </tr> 
  <tr> 
   <td>Page</td> 
   <td>Load</td> 
   <td>在这部分ASP.NET控件完全被加载且在这里你可以写UI操作逻辑或任何其他逻辑。<strong>NOTE：</strong><span style="text-decoration:underline;">这个事件也是我们最常见且最常用的一个事件。</span></td> 
  </tr> 
  <tr> 
   <td>Page</td> 
   <td>Validate</td> 
   <td>如果在页面上你有验证器，你同样想在这里做一下检查。</td> 
  </tr> 
  <tr> 
   <td>Page</td> 
   <td>Render</td> 
   <td>是时候将输出发送到浏览器。如果你想对最终的HTML做些修改，你可以在这里输入你的HTML逻辑。</td> 
  </tr> 
  <tr> 
   <td>Page</td> 
   <td>Unload</td> 
   <td>页面对象从内存中卸载。</td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>PostRequestHandlerExecute</td> 
   <td>可以注入任何你想要的逻辑，在处理程序执行之后。</td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>ReleaseRequestState</td> 
   <td>如果你想要保存对某些状态变量的更改，例如：Session变量的值。</td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>UpdateRequestCache</td> 
   <td>在结束之前，你是否想要更新你的缓存。</td> 
  </tr> 
  <tr> 
   <td>HttpModule</td> 
   <td>EndRequest</td> 
   <td>这是将输出发送到客户端浏览器之前的最后一个阶段。</td> 
  </tr> 
 </tbody> 
</table>

## **④自定义处理逻辑** ##

**　　**我们可以通过一个示例程序代码来展示以上介绍的那些事件是怎样被最终触发的。在这个示例中，我们已经创建了一个HttpModule和HttpHandler，并且也在所有的事件中通过添加自定义逻辑代码展示了一个简单的响应。

下面是**HttpModule**类，它跟踪了所有的事件并将其添加到了一个全局的集合中。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

public class clsHttpModule : IHttpModule
    {
        ...... 
        void OnUpdateRequestCache(object sender, EventArgs a)
        {
            objArrayList.Add("httpModule:OnUpdateRequestCache");
        }
        void OnReleaseRequestState(object sender, EventArgs a)
        {
            objArrayList.Add("httpModule:OnReleaseRequestState");
        }
        void OnPostRequestHandlerExecute(object sender, EventArgs a)
        {     objArrayList.Add("httpModule:OnPostRequestHandlerExecute");
        }
        void OnPreRequestHandlerExecute(object sender, EventArgs a)
        {  objArrayList.Add("httpModule:OnPreRequestHandlerExecute");
        }
        void OnAcquireRequestState(object sender, EventArgs a)
        {
            objArrayList.Add("httpModule:OnAcquireRequestState");
        }
        void OnResolveRequestCache(object sender, EventArgs a)
        {
            objArrayList.Add("httpModule:OnResolveRequestCache");
        }
        void OnAuthorization(object sender, EventArgs a)
        {
            objArrayList.Add("httpModule:OnAuthorization");
        }
        void OnAuthentication(object sender, EventArgs a)
        {
            objArrayList.Add("httpModule:AuthenticateRequest");
        }
        void OnBeginrequest(object sender, EventArgs a)
        {
            objArrayList.Add("httpModule:BeginRequest");
        }
        void OnEndRequest(object sender, EventArgs a)
        {
            objArrayList.Add("httpModule:EndRequest");
            objArrayList.Add("<hr>");
            foreach (string str in objArrayList)
            {
                httpApp.Context.Response.Write(str + "<br>") ;
            }
        } 
    }

下面是**HttpHandler**类的一个代码片段，它跟踪了**ProcessRequest**事件。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

public class clsHttpHandler : IHttpHandler
    {
        public void ProcessRequest(HttpContext context)
        {             clsHttpModule.objArrayList.Add("HttpHandler:ProcessRequest");
            context.Response.Redirect("Default.aspx");
        }
    }

同上，我们也可以跟踪来自**ASP.NET Page**页面的所有事件。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

public partial class _Default : System.Web.UI.Page 
    {
        protected void Page_init(object sender, EventArgs e)
        {
            clsHttpModule.objArrayList.Add("Page:Init");
        }
    
        protected void Page_Load(object sender, EventArgs e)
        {
            clsHttpModule.objArrayList.Add("Page:Load");
        }
    
        public override void Validate() 
        {
            clsHttpModule.objArrayList.Add("Page:Validate");
        }
    
        protected void Button1_Click(object sender, EventArgs e)
        {
            clsHttpModule.objArrayList.Add("Page:Event");
        }
    
        protected override void Render(HtmlTextWriter output) 
        {
            clsHttpModule.objArrayList.Add("Page:Render");
            base.Render(output);
        }
    
        protected void Page_Unload(object sender, EventArgs e)
        {
            clsHttpModule.objArrayList.Add("Page:UnLoad");
        }
    }

下图则显示了上面我们所讨论的所有事件的执行顺序：

![051756023598115.jpg][]

# **二、WebForm经历的管道事件概览** #

**　　**在ASP.NET WebForm应用中，其在请求处理管道中主要经历了**三个重要阶段：**

## ①在第八个事件中创建Page类对象并转换为IHttpHandler接口 ##

从上面的介绍中可以看到，第八个事件是：**PostMapRequestHandler**。在这个事件中，对于访问不同的资源类型，ASP.NET具有不同的HttpHandler对其进程处理。对于每个请求，ASP.NET会通过扩展名选择匹配相应的HttpHandler类型，成功匹配后，该实现被触发。因此，如果请求的扩展名是**.aspx**，便会生成**Page**类对象，而Page类对象是实现了**IHttpHandler**接口的。

![051829272343182.jpg][]

## ②在第九个到第十事件之间根据SessionId获取Session ##

![sessionId][]

从上面的介绍中可以看到，第九到第十个事件是：**AcquireRequestState**，**PostAcquireRequestState**。这期间首先会接收到浏览器发过来的SessionId，然后先会将IHttpHandler接口尝试转换为**IRequiresSessionState**接口，如果转换成功，ASP.NET会根据这个SessionId到服务器的Session池中去查找所对应的Session对象，并将这个Session对象赋值到HttpContext对象的Session属性。如果尝试转换为IRequiresSessionState接口不成功，则不加载Session。

![sessionstate][]

## ③在第十一个事件与第十二个事件之间执行页面生命周期 ##

从上面的介绍中可以看到，第十一和第十二个事件是：**PreRequestHandlerExecute**，**PostRequestHandlerExecute**。在这两个事件之间，ASP.NET最终通过请求资源类型相对应的**HttpHandler**实现对请求的处理，其实现方式是调用在第八个事件创建的页面对象的**ProcessRequest**方法。

![051837105625665.jpg][]　　在**FrameworkInitialize()**这个方法内部就开始打造WebForm的页面控件树，在其中调用了**ProcessRequestMain**方法，在这个方法里面就执行了整个ASP.NET WebFom页面生命周期。至于WebForm页面生命周期的细节，我们在本系列后续的**Part 4**再来细细研究。

> 当我们直接使用**\*.ashx**页面的时候，它的ProcessRequest()方法就直接调用了一个FrameworkInitialize()，并最终生成响应报文，发送回客户端。
> 
> 当我们在使用 **\*.aspx**页面的时候，它继承自Page类，而Page类实现了IHttpHandler接口，然后了调用Page类的ProcessRequest()方法，其中会构建页面控件树，然后一个一个地去呈现。

# **三、ASP.NET MVC经历的管道事件****概览** #

**　　**在ASP.NET MVC中，最核心的当属“**路由系统**”，而路由系统的核心则源于一个强大的**System.Web.Routing.dll**组件。

![052250268281320.jpg][]

在这个System.Web.Routing.dll中，有一个最重要的类叫做**UrlRoutingModule**，它是一个实现了**IHttpModule**接口的类，在请求处理管道中专门针对ASP.NET MVC请求进行处理。首先，我们要了解一下UrlRoutingModule是如何起作用的。

（1）IIS网站的配置可以分为两个块：全局 Web.config 和本站 Web.config。Asp.Net Routing属于全局性的，所以它配置在全局Web.Config 中，我们可以在如下路径中找到：“$\\Windows\\Microsoft.NET\\Framework\\版本号\\Config\\Web.config“

![复制代码][Image 1]

<?xml version="1.0" encoding="utf-8"?>
     
     <configuration>
         <system.web>
             <httpModules>
                 <add name="UrlRoutingModule-4.0" type="System.Web.Routing.UrlRoutingModule" />
             </httpModules>
        </system.web>
     </configuration>

![复制代码][Image 1]

（2）通过在全局Web.Config中注册 **System.Web.Routing.UrlRoutingModule**，IIS请求处理管道接到请求后，就会加载 UrlRoutingModule类型的**Init()**方法。其源码入下：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

public class UrlRoutingModule : IHttpModule
    {
        // Fields
        private static readonly object _contextKey = new object();
        private static readonly object _requestDataKey = new object();
        private RouteCollection _routeCollection;
     
        // Methods
        protected virtual void Dispose()
        {
        }
     
        protected virtual void Init(HttpApplication application)
        {
            if (application.Context.Items[_contextKey] == null)
            {
                application.Context.Items[_contextKey] = _contextKey;
                // 这里为UrlRoutingModule 注册了一个PostResolveRequestCache 事件处理方法：OnApplicationPostResolveRequestCache().
                application.PostResolveRequestCache += new EventHandler(this.OnApplicationPostResolveRequestCache);
            }
        }
     
        private void OnApplicationPostResolveRequestCache(object sender, EventArgs e)
        {
            HttpContextBase context = new HttpContextWrapper(((HttpApplication) sender).Context);
            this.PostResolveRequestCache(context);
        }
     
        [Obsolete("This method is obsolete. Override the Init method to use the PostMapRequestHandler event.")]
        public virtual void PostMapRequestHandler(HttpContextBase context)
        {
        }
     
        public virtual void PostResolveRequestCache(HttpContextBase context)
        {
            RouteData routeData = this.RouteCollection.GetRouteData(context);
            if (routeData != null)
            {
                IRouteHandler routeHandler = routeData.RouteHandler;
                if (routeHandler == null)
                {
                    throw new InvalidOperationException(string.Format(CultureInfo.CurrentUICulture, SR.GetString("UrlRoutingModule_NoRouteHandler"), new object[0]));
                }
                if (!(routeHandler is StopRoutingHandler))
                {
                    RequestContext requestContext = new RequestContext(context, routeData);
                    context.Request.RequestContext = requestContext;
                    IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext);
                    if (httpHandler == null)
                    {
                        throw new InvalidOperationException(string.Format(CultureInfo.CurrentUICulture, SR.GetString("UrlRoutingModule_NoHttpHandler"), new object[] { routeHandler.GetType() }));
                    }
                    if (httpHandler is UrlAuthFailureHandler)
                    {
                        if (!FormsAuthenticationModule.FormsAuthRequired)
                        {
                            throw new HttpException(0x191, SR.GetString("Assess_Denied_Description3"));
                        }
                        UrlAuthorizationModule.ReportUrlAuthorizationFailure(HttpContext.Current, this);
                    }
                    else
                    {
                        context.RemapHandler(httpHandler);
                    }
                }
            }
        }
     
        void IHttpModule.Dispose()
        {
            this.Dispose();
        }
     
        void IHttpModule.Init(HttpApplication application)
        {
            this.Init(application);
        }
     
        // Properties
        public RouteCollection RouteCollection
        {
            get
            {
                if (this._routeCollection == null)
                {
                    this._routeCollection = RouteTable.Routes;
                }
                return this._routeCollection;
            }
            set
            {
                this._routeCollection = value;
            }
        }
    }

从源码中可以看出，在UrlRoutingModule中为请求处理管道中的第七个事件PostResolveRequestCache注册了一个事件处理方法：OnApplicationPostResolveRequestCache。从这里可以看出：**ASP.NET MVC的入口在UrlRoutingModule，即订阅了HttpApplication的第7个管道事件PostResolveRequestCahce。换句话说，是在HtttpApplication的第7个管道事件处对请求进行了拦截。**

**![052314287813763.png][]**

现在我们将ASP.NET MVC的请求处理分为**两个重要阶段**来看看：

## ①在第七个事件中创建实现了IHttpHandler接口的MvcHandler ##

当请求到达UrlRoutingModule的时候，UrlRoutingModule取出请求中的Controller、Action等RouteData信息，与路由表中的所有规则进行匹配，若匹配，把请求交给IRouteHandler，即**MVCRouteHandler**。我们可以看下UrlRoutingModule的源码来看看，以下是几句核心的代码：

![复制代码][Image 1]

public virtual void PostResolveRequestCache(HttpContextBase context)
    {
        // 通过RouteCollection的静态方法GetRouteData获取到封装路由信息的RouteData实例
        RouteData routeData = this.RouteCollection.GetRouteData(context);
        if (routeData != null)
        {
            // 再从RouteData中获取MVCRouteHandler
            IRouteHandler routeHandler = routeData.RouteHandler;
            ......
            if (!(routeHandler is StopRoutingHandler))
            {
                ......
                // 调用 IRouteHandler.GetHttpHandler()，获取的IHttpHandler 类型实例，它是由 IRouteHandler.GetHttpHandler获取的，这个得去MVC的源码里看
                IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext);
                ......
                // 合适条件下，把之前将获取的IHttpHandler 类型实例 映射到IIS HTTP处理管道中
                context.RemapHandler(httpHandler);
            }
        }
    }

![复制代码][Image 1]

**MVCRouteHandler**的作用是用来生成实现**IHttpHandler**接口的**MvcHandler**：

![复制代码][Image 1]

namespace System.Web.Routing
    {  
        public interface IRouteHandler
        {       
            IHttpHandler GetHttpHandler(RequestContext requestContext);
        }
    }

![复制代码][Image 1]

那么，**MvcRouteHandler**从何而来呢？众所周知，ASP.NET MVC项目启动是从Global中的Application\_Start()方法开始的，那就去看看它：

![复制代码][Image 1]

public class MvcApplication : System.Web.HttpApplication
        {
            protected void Application_Start()
            {
                ......
                //这里要注册路由了
                RouteConfig.RegisterRoutes(RouteTable.Routes);
                BundleConfig.RegisterBundles(BundleTable.Bundles);
            }
        }
    
        public class RouteConfig
        {
            public static void RegisterRoutes(RouteCollection routes)
            {
                routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
                // 玄机就在这了，这个MapRoute位于System.Web.Mvc.RouteCollectionExtensions
                routes.MapRoute(
                    name: "Default",
                    url: "{controller}/{action}/{id}",
                    defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
                );
            }
        }

![复制代码][Image 1]

于是，我们再去看看Route类的这个**MapRoute()**方法的源码：

![复制代码][Image 1]

public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces) 
            {
                ......
    　　　　　　　// 终于等到你，还好我没放弃。
                Route route = new Route(url, new MvcRouteHandler())             {
                    Defaults = new RouteValueDictionary(defaults),
                    Constraints = new RouteValueDictionary(constraints),
                    DataTokens = new RouteValueDictionary()
                };
                ......
                return route;
            }

![复制代码][Image 1]

从上面的源码可以得知为什么可以从RouteData中拿到**MvcRouteHadnler**？因为当我们在HttpApplication的第一个管道事件，使用**MapRoute()**方法注册路由的时候，已经通过Route类的构造函数把**MvcRouteHandler**注入到路由中了。

刚刚我们知道**MvcRouteHandler**是用来生成实现**IHttpHandler**接口的**MvcHandler**，那么我们继续从**UrlRoutingModule**的源码可以看到，通过HttpHandler的**GetHttpHandler()**方法获取到了实现了**IHttpHandler**接口的**MvcHandler：**

// 调用 IRouteHandler.GetHttpHandler()，获取的IHttpHandler 类型实例，它是由 IRouteHandler.GetHttpHandler获取的，这个得去MVC的源码里看
                IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext);
                ......
                // 合适条件下，把之前将获取的IHttpHandler 类型实例 映射到IIS HTTP处理管道中
                context.RemapHandler(httpHandler);

于是，我们进入ASP.NET MVC的源码看看MvcHandlerd的实现，这里我看的是MVC 4.0的源码：

protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
            {
           　　　requestContext.HttpContext.SetSessionStateBehavior(GetSessionStateBehavior(requestContext));
                return new MvcHandler(requestContext);
            }

可以看出，在这里创建了**MvcHandler**实例。换句话说，MvcRouteHandler把请求交给了MvcHandler去做请求处理管道中后续事件的处理操作了。

**![060017250319097.png][]**

## ②在第十一个事件与第十二个事件之间调用MvcHandler的ProcessRequest()方法 ##

（1）在WebForm中，此阶段会调用Page类对象的ProcessRequest()方法。在ASP.NET MVC中，会调用MvcHandler的ProcessRequest()方法，此方法会激活具体请求的Controller类对象，触发Action方法，返回ActionResult实例。

（2）如果ActionResult是非ViewResult，比如JsonResult, ContentResult，这些内容将直接被输送到Response响应流中，显示给客户端；如果是ViewResult，就会进入下一个渲染视图环节。

（3）在渲染视图环节，ViewEngine找到需要被渲染的视图，View被加载成WebViewPage<TModel>类型，并渲染生成Html，最终返回Html。

> **TIP：**有关此ProcessRequest()处理环节的详细内容，请等待本系列**Part 5**中的介绍。

# **参考资料** #

***致谢：*本文参阅了大量园友的文章，也直接使用了大量园友制作的图，在此对以下各位园友表示感谢。**

（1）Darren Ji，《ASP.NET MVC请求处理管道声明周期的19个关键环节》：[http://www.cnblogs.com/darrenji/p/3795661.html][http_www.cnblogs.com_darrenji_p_3795661.html]

（2）木宛城主，《ASP.NET那点不为人知的事儿》：[http://www.cnblogs.com/OceanEyes/archive/2012/08/13/aspnetEssential-1.html][http_www.cnblogs.com_OceanEyes_archive_2012_08_13_aspnetEssential-1.html]

（3）Tony He，《ASP.NET请求处理机制》：[http://www.cnblogs.com/cilence/archive/2012/05/28/2520712.html][http_www.cnblogs.com_cilence_archive_2012_05_28_2520712.html]

（4）两会的博客，《IIS是怎样处理ASP.NET请求的》：[http://www.cnblogs.com/hkncd/archive/2012/03/23/2413917.html][http_www.cnblogs.com_hkncd_archive_2012_03_23_2413917.html]

（5）wjn2000，《ASP.NET请求处理过程（IIS6）》：[http://www.cnblogs.com/wjn2010/archive/2011/04/21/2024341.html][http_www.cnblogs.com_wjn2010_archive_2011_04_21_2024341.html]

（6）农村出来的大学生，《ASP.NET网页请求处理全过程（反编译）》：[http://www.cnblogs.com/poorpan/archive/2011/09/25/2190308.html][http_www.cnblogs.com_poorpan_archive_2011_09_25_2190308.html]

（7）碧血轩，《ASP.NET页面生命周期》，[http://www.cnblogs.com/xhwy/archive/2012/05/20/2510178.html][http_www.cnblogs.com_xhwy_archive_2012_05_20_2510178.html]

（8）吴秦，《ASP.NET 应用程序与页面生命周期（意译）》，[http://www.cnblogs.com/skynet/archive/2010/04/29/1724020.html][http_www.cnblogs.com_skynet_archive_2010_04_29_1724020.html]

（9）我自己，《【翻译】ASP.NET应用程序和页面声明周期》：[http://www.cnblogs.com/edisonchou/p/3958305.html][http_www.cnblogs.com_edisonchou_p_3958305.html]

（10）Shivprasad koirala，《ASP.NET Application and Page Life Cycle》：[http://www.codeproject.com/Articles/73728/ASP-NET-Application-and-Page-Life-Cycle][http_www.codeproject.com_Articles_73728_ASP-NET-Application-and-Page-Life-Cycle]

（11）学而不思则罔，《ASP.NET Routing与MVC之一：请求如何到达MVC》：[http://www.cnblogs.com/acejason/p/3869731.html][http_www.cnblogs.com_acejason_p_3869731.html]

（12）初心不可忘，《综述：ASP.NET MVC请求处理管道》：[http://www.cnblogs.com/luguobin/archive/2013/03/15/2962458.html][http_www.cnblogs.com_luguobin_archive_2013_03_15_2962458.html]

作者：[周旭龙][Link 3]

出处：[http://edisonchou.cnblogs.com/][http_edisonchou.cnblogs.com]

技术交流Q群: 816425449

转载于:https://www.cnblogs.com/yiting/p/11070445.html

[Link 1]: http://www.cnblogs.com/edisonchou/p/4192017.html
[Link 2]: http://www.cnblogs.com/edisonchou/p/4195259.html
[WebForm]: http://www.cnblogs.com/edisonchou/p/4216337.html
[MVC]: http://www.cnblogs.com/edisonchou/p/4226558.html
[051721569687793.jpg]: /images/20211104/1fffa8c7a517467d9f9d960694def1c0.png
[051739482654839.jpg]: /images/20211104/d0bb486763894d4b83cf51f1334f06da.png
[051740074374283.jpg]: /images/20211104/a2edd4bf28a9431991bfd21ac1979051.png
[Image 1]: 
[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211104/320bc93008c2483997c63079f6997283.png
[051756023598115.jpg]: /images/20211104/913f844079544cb08ab23667ebecc75c.png
[051829272343182.jpg]: /images/20211104/4fcaba25bb4c40fbba16c6e4422956d1.png
[sessionId]: /images/20211104/2aef38b9544043bc95fd402f9a7e128c.png
[sessionstate]: /images/20211104/c7797a83f45046a888d9a61567fb289c.png
[051837105625665.jpg]: /images/20211104/88ded3b2aff54ca799f77b6d90fedfe4.png
[052250268281320.jpg]: /images/20211104/08655f48ac3c452489569c8506416c18.png
[052314287813763.png]: /images/20211104/e6e0f530e24d43789c7f91d842545d98.png
[060017250319097.png]: /images/20211104/ea5dc99a926540c8804f32b427c3983c.png
[http_www.cnblogs.com_darrenji_p_3795661.html]: http://www.cnblogs.com/darrenji/p/3795661.html
[http_www.cnblogs.com_OceanEyes_archive_2012_08_13_aspnetEssential-1.html]: http://www.cnblogs.com/OceanEyes/archive/2012/08/13/aspnetEssential-1.html
[http_www.cnblogs.com_cilence_archive_2012_05_28_2520712.html]: http://www.cnblogs.com/cilence/archive/2012/05/28/2520712.html
[http_www.cnblogs.com_hkncd_archive_2012_03_23_2413917.html]: http://www.cnblogs.com/hkncd/archive/2012/03/23/2413917.html
[http_www.cnblogs.com_wjn2010_archive_2011_04_21_2024341.html]: http://www.cnblogs.com/wjn2010/archive/2011/04/21/2024341.html
[http_www.cnblogs.com_poorpan_archive_2011_09_25_2190308.html]: http://www.cnblogs.com/poorpan/archive/2011/09/25/2190308.html
[http_www.cnblogs.com_xhwy_archive_2012_05_20_2510178.html]: http://www.cnblogs.com/xhwy/archive/2012/05/20/2510178.html
[http_www.cnblogs.com_skynet_archive_2010_04_29_1724020.html]: http://www.cnblogs.com/skynet/archive/2010/04/29/1724020.html
[http_www.cnblogs.com_edisonchou_p_3958305.html]: http://www.cnblogs.com/edisonchou/p/3958305.html
[http_www.codeproject.com_Articles_73728_ASP-NET-Application-and-Page-Life-Cycle]: http://www.codeproject.com/Articles/73728/ASP-NET-Application-and-Page-Life-Cycle
[http_www.cnblogs.com_acejason_p_3869731.html]: http://www.cnblogs.com/acejason/p/3869731.html
[http_www.cnblogs.com_luguobin_archive_2013_03_15_2962458.html]: http://www.cnblogs.com/luguobin/archive/2013/03/15/2962458.html
[Link 3]: http://www.cnblogs.com/edisonchou/
[http_edisonchou.cnblogs.com]: http://edisonchou.cnblogs.com/