MSDN Documentation

Understanding ASP.NET Request Processing

This document outlines the lifecycle of an HTTP request as it is processed by an ASP.NET application. Understanding this process is crucial for optimizing performance, debugging issues, and building robust web applications.

The Request Pipeline

When a client (e.g., a web browser) sends an HTTP request to an ASP.NET web server, the request goes through a series of stages before a response is generated and sent back. This series of stages is often referred to as the request pipeline.

Key Stages in Request Processing

• HTTP Listener: The web server (e.g., IIS) receives the raw HTTP request from the network.
• HTTP.sys: On Windows, the HTTP protocol stack (HTTP.sys) handles the initial request processing, queuing it for the appropriate application pool.
• IIS Worker Process: The request is passed to an Internet Information Services (IIS) worker process (w3wp.exe).
• ASP.NET Runtime: Within the worker process, the ASP.NET runtime takes over.
• Global.asax (HttpApplication): The request is routed to an instance of HttpApplication. This is where application-level event handlers are registered (e.g., Application_BeginRequest, Application_AuthenticateRequest).
• Modules (HttpModules): A series of HttpModules are executed. These modules can intercept and process requests at various points. Examples include:
  • Authentication Modules
  • Authorization Modules
  • Session State Modules
  • UrlRoutingModule (for routing)
• Handler Identification: ASP.NET determines which handler will process the request. This could be a page handler (for `.aspx` files), a generic handler, a static file handler, or a handler identified by routing rules.
• Handler Execution: The identified handler processes the request. For a page, this involves executing server-side code, rendering HTML, and then passing it back up the pipeline.
• Response Generation: The generated response is sent back through the pipeline.
• Modules (Output): Modules may again have a chance to modify the response before it is sent to the client.
• HTTP.sys and IIS: The final response is sent back to the client via HTTP.sys and IIS.

Core Components

HttpApplication and Events

The HttpApplication class is the core of the ASP.NET request processing model. It exposes a series of events that fire at different stages of the request lifecycle, allowing developers to hook into the process:

• Init
• BeginRequest
• AuthenticateRequest
• AuthorizeRequest
• ResolveRequestCache
• AcquireRequestState
• PreRequestHandlerExecute
• PostRequestHandlerExecute
• ReleaseRequestState
• UpdateRequestCache
• LogRequest
• EndRequest

These events are typically handled in the Global.asax file or in custom HttpModules.

HttpModules

HttpModules are classes that implement the IHttpModule interface. They are registered in the <httpModules> section of the web.config file (or system.webServer/modules for IIS 7+ integrated pipeline). They provide a powerful mechanism for extending the ASP.NET pipeline without modifying the core runtime.

Example of a simple module registration in web.config:

<system.web>
    <httpModules>
        <add name="MyCustomModule" type="MyNamespace.MyCustomModule, MyAssembly"/>
    </httpModules>
</system.web>

Handlers

An ASP.NET handler is responsible for processing a specific type of request and generating a response. The handler is determined based on the requested file extension or routing rules. Common handlers include:

• Page Handler: Processes `.aspx` files.
• Static File Handler: Serves static files like `.html`, `.css`, `.js`, `.jpg`.
• UrlRoutingModule: Handles requests based on URL routing patterns.

Example Scenario: Processing an .aspx Page

1. Request arrives for MyPage.aspx.
2. Global.asax events fire (e.g., Application_BeginRequest).
3. HttpModules execute their pre-request logic.
4. ASP.NET identifies the Page Handler for `.aspx` files.
5. The Page Handler is instantiated.
6. Page events fire (e.g., Page_Init, Page_Load).
7. The Page's rendering logic executes.
8. The generated HTML is passed back up the pipeline.
9. HttpModules execute their post-request logic (potentially modifying the response).
10. The response is sent back to the client.

Understanding these stages allows developers to implement custom logic at specific points in the request lifecycle, enabling features like custom authentication, logging, response compression, and more.