通过.net reflector了解asp.net站点的请求与响应过程
通过.NET Reflerctor我们可以反编译看一个请求是如何被响应处理的。以下为请求被响应处理的过程涉及到的主要类
- ISAPIRuntime
- HttpRuntime
- HttpApplicationFactory
- HttpApplication
- HttpContext
- HttpModule
- HttpHanler
使用.net reflerctor读取.net 3.5 frameword类库
一、请求如何到达w3wp.exe进程
当站点已部署在IIS下时，这时有客户端请求到达，首先被www服务进程inetinfo.exe捕获，根据请求页面的后缀名由IIS配置处理程序映射的dll处理，如果是aspx页面就交由aspnet_isapi.dll处理，aspnet_isapi.dll再将请求分发给w3wp.exe进程（也就是我们在VS调试的时候附加的进程）。
二、如何创建HttpApplication管线
w3wp.exe进程先调用System.Web.Hosting下的ISAPIRuntime.ProcessRequest方法触发HttpRuntime
View Code
public int ProcessRequest(IntPtr ecb, int iWRType)
{
IntPtr zero = IntPtr.Zero;
if (iWRType == 2)
{
zero = ecb;
ecb = UnsafeNativeMethods.GetEcb(zero);
}
ISAPIWorkerRequest wr = null;
try
{
bool useOOP = iWRType == 1;
wr = ISAPIWorkerRequest.CreateWorkerRequest(ecb, useOOP);
wr.Initialize();
string appPathTranslated = wr.GetAppPathTranslated();
string appDomainAppPathInternal = HttpRuntime.AppDomainAppPathInternal;
if ((appDomainAppPathInternal == null) || StringUtil.EqualsIgnoreCase(appPathTranslated, appDomainAppPathInternal))
{
HttpRuntime.ProcessRequestNoDemand(wr);
return 0;
}
HttpRuntime.ShutdownAppDomain(ApplicationShutdownReason.PhysicalApplicationPathChanged, SR.GetString("Hosting_Phys_Path_Changed", new object[] { appDomainAppPathInternal, appPathTranslated }));
return 1;
}
catch (Exception exception)
{
try
{
WebBaseEvent.RaiseRuntimeError(exception, this);
}
catch
{
}
if ((wr == null) || !(wr.Ecb == IntPtr.Zero))
{
throw;
}
if (zero != IntPtr.Zero)
{
UnsafeNativeMethods.SetDoneWithSessionCalled(zero);
}
if (exception is ThreadAbortException)
{
Thread.ResetAbort();
}
return 0;
}
}
ISAPIRuntime生成了一个HttpWorkerRequest对象（即HttpContext.Current)，并传递给HttpRuntime。接着执行HttpRuntime.ProcessRequestNoDemand方法
View Code
internal static void ProcessRequestNoDemand(HttpWorkerRequest wr)
{
RequestQueue queue = _theRuntime._requestQueue;
if (queue != null)
{
wr = queue.GetRequestToExecute(wr);
}
if (wr != null)
{
CalculateWaitTimeAndUpdatePerfCounter(wr);
wr.ResetStartTime();
ProcessRequestNow(wr);
}
}
转到HttpRuntime.ProcessRequestNow方法
View Code
internal static void ProcessRequestNow(HttpWorkerRequest wr)
{
_theRuntime.ProcessRequestInternal(wr);
}
继续调用HttpRuntime.ProcessRequestInternal方法
View Code
private void ProcessRequestInternal(HttpWorkerRequest wr)
{
HttpContext context;
try
{
context = new HttpContext(wr, false);
}
catch
{
wr.SendStatus(400, "Bad Request");
wr.SendKnownResponseHeader(12, "text/html; charset=utf-8");
byte[] bytes = Encoding.ASCII.GetBytes("<html><body>Bad Request</body></html>");
wr.SendResponseFromMemory(bytes, bytes.Length);
wr.FlushResponse(true);
wr.EndOfRequest();
return;
}
wr.SetEndOfSendNotification(this._asyncEndOfSendCallback, context);
Interlocked.Increment(ref this._activeRequestCount);
HostingEnvironment.IncrementBusyCount();
try
{
try
{
this.EnsureFirstRequestInit(context);
}
catch
{
if (!context.Request.IsDebuggingRequest)
{
throw;
}
}
context.Response.InitResponseWriter();
IHttpHandler applicationInstance = HttpApplicationFactory.GetApplicationInstance(context);
if (applicationInstance == null)
{
throw new HttpException(SR.GetString("Unable_create_app_object"));
}
if (EtwTrace.IsTraceEnabled(5, 1))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_START_HANDLER, context.WorkerRequest, applicationInstance.GetType().FullName, "Start");
}
if (applicationInstance is IHttpAsyncHandler)
{
IHttpAsyncHandler handler2 = (IHttpAsyncHandler) applicationInstance;
context.AsyncAppHandler = handler2;
handler2.BeginProcessRequest(context, this._handlerCompletionCallback, context);
}
else
{
applicationInstance.ProcessRequest(context);
this.FinishRequest(context.WorkerRequest, context, null);
}
}
catch (Exception exception)
{
context.Response.InitResponseWriter();
this.FinishRequest(wr, context, exception);
}
}
该方法创建了我们在后面经常用到的HttpContext上下文（请求与响应信息），接着通过 HttpApplicationFactory获取HttpApplication实例。
仔细看一下IHttpHandler applicationInstance = HttpApplicationFactory.GetApplicationInstance(context) 方法
View Code
internal static IHttpHandler GetApplicationInstance(HttpContext context)
{
if (_customApplication != null)
{
return _customApplication;
}
if (context.Request.IsDebuggingRequest)
{
return new HttpDebugHandler();
}
_theApplicationFactory.EnsureInited();
_theApplicationFactory.EnsureAppStartCalled(context);
return _theApplicationFactory.GetNormalApplicationInstance(context);
}
如果HttpApplication实例存在就直接返回，不存就先执行_theApplicationFactory.EnsureInited();
View Code
private void EnsureInited()
{
if (!this._inited)
{
lock (this)
{
if (!this._inited)
{
this.Init();
this._inited = true;
}
}
}
}
调用HttpApplicationFactory的Init方法（HttpApplicationFactory是单例模式）
View Code
private void Init()
{
if (_customApplication == null)
{
try
{
try
{
this._appFilename = GetApplicationFile();
this.CompileApplication();
}
finally
{
this.SetupChangesMonitor();
}
}
catch
{
throw;
}
}
}
主要看两个方法
View Code
internal static string GetApplicationFile()
{
return Path.Combine(HttpRuntime.AppDomainAppPathInternal, "global.asax");
}
private void SetupChangesMonitor()
{
FileChangeEventHandler callback = new FileChangeEventHandler(this.OnAppFileChange);
HttpRuntime.FileChangesMonitor.StartMonitoringFile(this._appFilename, callback);
if (this._fileDependencies != null)
{
foreach (string str in this._fileDependencies)
{
HttpRuntime.FileChangesMonitor.StartMonitoringFile(HostingEnvironment.MapPathInternal(str), callback);
}
}
}
读取global.asax文件（很熟悉吧，应用程序的全局配置文件），并添加事件监视。
再回到GetApplicationInstance方法中，执行_theApplicationFactory.GetNormalApplicationInstance(context) 从_freeList读取HttpApplication实例
或者通过反射创建新的HttpApplication实例。
View Code
private HttpApplication GetNormalApplicationInstance(HttpContext context)
{
HttpApplication application = null;
lock (this._freeList)
{
if (this._numFreeAppInstances > 0)
{
application = (HttpApplication) this._freeList.Pop();
this._numFreeAppInstances--;
if (this._numFreeAppInstances < this._minFreeAppInstances)
{
this._minFreeAppInstances = this._numFreeAppInstances;
}
}
}
if (application == null)
{
application = (HttpApplication) HttpRuntime.CreateNonPublicInstance(this._theApplicationType);
using (new ApplicationImpersonationContext())
{
application.InitInternal(context, this._state, this._eventHandlerMethods);
}
}
return application;
}
三、何时加载HttpModule
当HttpApplication首次被创建的时候，我们可以看到上面的方法的实例化调用了HttpApplication的方法
application.InitInternal(context, this._state, this._eventHandlerMethods)，这个方法将首先将HttpApplication实例绑到
HttpContext.ApplicationInstance 上，这样我们通过上下文可以找到HttpApplication实例。接着又调用了 this.InitModules()
去加载配置文件中的HttpModule
private void InitModules()
{
this._moduleCollection = RuntimeConfig.GetAppConfig().HttpModules.CreateModules();
this.InitModulesCommon();
}
private void InitModulesCommon()
{
int count = this._moduleCollection.Count;
for (int i = 0; i < count; i++)
{
this._currentModuleCollectionKey = this._moduleCollection.GetKey(i);
this._moduleCollection[i].Init(this);
}
this._currentModuleCollectionKey = null;
this.InitAppLevelCulture();
}
Module被反射加载后，在InitMoulesCommon中会调会HttpModule的Init方法。
我们来看一配置文件，Module加载是按照配置文件的顺序，所以事件被触发也是按照这个顺序。另外.net 的module是优先加载的，例如Session等。
View Code
<httpModules>
<add name="ScriptModule" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
<add name="UrlRoutingModule" type="System.Web.Routing.UrlRoutingModule, System.Web.Routing, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
</httpModules>
我们再回HttpApplication的 InitInternal方法，当 InitModules()创建HttpModuleCollection后，在HookupEventHandlersForApplicationAndModules方法中绑定Module的事件处理
接着就是HttpApplication的管线事件和HttpHandler的有序绑定。
接着就是HttpApplication的管线事件和HttpHandler的有序绑定。
View Code
if (HttpRuntime.UseIntegratedPipeline)
{
this._stepManager = new PipelineStepManager(this);
}
else
{
this._stepManager = new ApplicationStepManager(this);
}
this._stepManager.BuildSteps(this._resumeStepsWaitCallback);
ApplicationManager和PipelineStepManager都继随自HttpApplication.StepManager。SetpManager主HttpApplication的内部调度类，主要负责HttpApplication管线的事件和HttpHandler有序绑定和执行工作。
题外话：HttpApplication本身不对请求做任何处理，而是交由HttpModule与HttpHandler，而HttpModule不仅决定了使用什么HttpHandler，并且还可以修改请求和响应信息。当HttpModule把处理权交给HttpHandler后，HttpHandler才能从上下文取出请求做相应处理。（WebForm与MVC差别从这里开始不同了）。
四、HttpHandler
HttpHandler是我们真正.net 程序处理代码的位置（Page,Controller，Session操作等等）
BuildSteps方法在绑定事件的同时，其中红色标记位加载了映射和要执行的HttpHandler
里只是建立了好管线事件的触发顺序以及HttpHandler的加载与执行句柄等，但是直正触发管道执行的，还是要回到HttpRuntime的 ProcessRequestInternal的方法中。steps.Add(new HttpApplication.MapHandlerExecutionStep(app))添加加载反射HttpHandler的MapHandlerExecutionSte到Steps中；注意他的Execute方法是加载。
View Code
internal class MapHandlerExecutionStep : HttpApplication.IExecutionStep
{
// Fields
private HttpApplication _application;
// Methods
internal MapHandlerExecutionStep(HttpApplication app)
{
this._application = app;
}
void HttpApplication.IExecutionStep.Execute()
{
HttpContext context = this._application.Context;
HttpRequest request = context.Request;
if (EtwTrace.IsTraceEnabled(5, 1))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_ENTER, context.WorkerRequest);
}
context.Handler = this._application.MapHttpHandler(context, request.RequestType, request.FilePathObject, request.PhysicalPathInternal, false);
if (EtwTrace.IsTraceEnabled(5, 1))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_LEAVE, context.WorkerRequest);
}
}
// Properties
bool HttpApplication.IExecutionStep.CompletedSynchronously
{
get
{
return true;
}
}
bool HttpApplication.IExecutionStep.IsCancellable
{
get
{
return false;
}
}
}
steps.Add(new HttpApplication.CallHandlerExecutionStep(app));这个CallHandlerExecutionStep是触发HttpHandler的Step,我们来看一下他的Exectue方法
View Code
internal class CallHandlerExecutionStep : HttpApplication.IExecutionStep
{
// Fields
private HttpApplication _application;
private AsyncCallback _completionCallback;
private IHttpAsyncHandler _handler;
private bool _sync;
// Methods
internal CallHandlerExecutionStep(HttpApplication app)
{
this._application = app;
this._completionCallback = new AsyncCallback(this.OnAsyncHandlerCompletion);
}
private void OnAsyncHandlerCompletion(IAsyncResult ar)
{
if (!ar.CompletedSynchronously)
{
HttpContext context = this._application.Context;
Exception error = null;
try
{
try
{
this._handler.EndProcessRequest(ar);
}
finally
{
context.Response.GenerateResponseHeadersForHandler();
}
}
catch (Exception exception2)
{
if ((exception2 is ThreadAbortException) || ((exception2.InnerException != null) && (exception2.InnerException is ThreadAbortException)))
{
this._application.CompleteRequest();
}
else
{
error = exception2;
}
}
if (EtwTrace.IsTraceEnabled(4, 4))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);
}
this._handler = null;
context.SetStartTime();
this.ResumeStepsWithAssert(error);
}
}
[PermissionSet(SecurityAction.Assert, Unrestricted=true)]
private void ResumeStepsWithAssert(Exception error)
{
this._application.ResumeStepsFromThreadPoolThread(error);
}
void HttpApplication.IExecutionStep.Execute()
{
HttpContext context = this._application.Context;
IHttpHandler handler = context.Handler;
if (EtwTrace.IsTraceEnabled(4, 4))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_ENTER, context.WorkerRequest);
}
if ((handler != null) && HttpRuntime.UseIntegratedPipeline)
{
IIS7WorkerRequest workerRequest = context.WorkerRequest as IIS7WorkerRequest;
if ((workerRequest != null) && workerRequest.IsHandlerExecutionDenied())
{
this._sync = true;
HttpException exception = new HttpException(0x193, SR.GetString("Handler_access_denied"));
exception.SetFormatter(new PageForbiddenErrorFormatter(context.Request.Path, SR.GetString("Handler_access_denied")));
throw exception;
}
}
if (handler == null)
{
this._sync = true;
}
else if (handler is IHttpAsyncHandler)
{
IHttpAsyncHandler handler2 = (IHttpAsyncHandler) handler;
this._sync = false;
this._handler = handler2;
IAsyncResult result = handler2.BeginProcessRequest(context, this._completionCallback, null);
if (result.CompletedSynchronously)
{
this._sync = true;
this._handler = null;
try
{
handler2.EndProcessRequest(result);
}
finally
{
context.Response.GenerateResponseHeadersForHandler();
}
if (EtwTrace.IsTraceEnabled(4, 4))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);
}
}
}
else
{
this._sync = true;
context.SyncContext.SetSyncCaller();
try
{
handler.ProcessRequest(context);
}
finally
{
context.SyncContext.ResetSyncCaller();
if (EtwTrace.IsTraceEnabled(4, 4))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);
}
context.Response.GenerateResponseHeadersForHandler();
}
}
}
// Properties
bool HttpApplication.IExecutionStep.CompletedSynchronously
{
get
{
return this._sync;
}
}
bool HttpApplication.IExecutionStep.IsCancellable
{
get
{
return !(this._application.Context.Handler is IHttpAsyncHandler);
}
}
}
注意Execute方法调用了HttpHandler的BeginProcessRequest或ProcessRequst。这就HttpHandler的直正接手处理请求的入口，但这里都StepManager的准备工作。
它的触发过程：->HttpRuntime获取到HttpApplication，并调用的HttpApplication.BeginProcessRequest->HttpApplication.StepManager.ResumeSteps
->HttpApplication.StepManager._execSteps[i].Execute ->HttpHandler.ProcessRequest
当通过IHttpHandler applicationInstance = HttpApplicationFactory.GetApplicationInstance(context); 获取实例后，HttpRuntime开始触发application的请求处理
即调用HttpApplication的BeginProcessRequest方法
View Code
if (applicationInstance is IHttpAsyncHandler)
{
IHttpAsyncHandler handler2 = (IHttpAsyncHandler) applicationInstance;
context.AsyncAppHandler = handler2;
handler2.BeginProcessRequest(context, this._handlerCompletionCallback, context);
}
else
{
applicationInstance.ProcessRequest(context);
this.FinishRequest(context.WorkerRequest, context, null);
}
看一下BeginProcessRequest方法
IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
{
this._context = context;
this._context.ApplicationInstance = this;
this._stepManager.InitRequest();
this._context.Root();
HttpAsyncResult result = new HttpAsyncResult(cb, extraData);
this.AsyncResult = result;
if (this._context.TraceIsEnabled)
{
HttpRuntime.Profile.StartRequest(this._context);
}
this.ResumeSteps(null);
return result;
}
void IHttpHandler.ProcessRequest(HttpContext context)
{
throw new HttpException(SR.GetString("Sync_not_supported"));
}
BeginProcessRequest方法调用StepManager的InitRequest（初始化执行顺序的参数），然后接着调用了最重要的 ResumeSteps方法，此方法将按顺序执行StepManager中保存HttpApplication绑定的事件及HttpHandler。
分析一下ResumeSteps 方法
View Code
[DebuggerStepperBoundary]
internal override void ResumeSteps(Exception error)
{
bool flag = false;
bool completedSynchronously = true;
HttpApplication application = base._application;
HttpContext context = application.Context;
HttpApplication.ThreadContext context2 = null;
AspNetSynchronizationContext syncContext = context.SyncContext;
lock (base._application)
{
try
{
context2 = application.OnThreadEnter();
}
catch (Exception exception)
{
if (error == null)
{
error = exception;
}
}
try
{
try
{
Label_0040:
if (syncContext.Error != null)
{
error = syncContext.Error;
syncContext.ClearError();
}
if (error != null)
{
application.RecordError(error);
error = null;
}
if (syncContext.PendingOperationsCount > 0)
{
syncContext.SetLastCompletionWorkItem(this._resumeStepsWaitCallback);
}
else
{
if ((this._currentStepIndex < this._endRequestStepIndex) && ((context.Error != null) || base._requestCompleted))
{
context.Response.FilterOutput();
this._currentStepIndex = this._endRequestStepIndex;
}
else
{
this._currentStepIndex++;
}
if (this._currentStepIndex >= this._execSteps.Length)
{
flag = true;
}
else
{
this._numStepCalls++;
context.SyncContext.Enable();
error = application.ExecuteStep(this._execSteps[this._currentStepIndex], ref completedSynchronously);
if (completedSynchronously)
{
this._numSyncStepCalls++;
goto Label_0040;
}
}
}
}
finally
{
if (context2 != null)
{
try
{
context2.Leave();
}
catch
{
}
}
}
}
catch
{
throw;
}
}
if (flag)
{
context.Unroot();
application.AsyncResult.Complete(this._numStepCalls == this._numSyncStepCalls, null, null);
application.ReleaseAppInstance();
}
}
留意代码会发现
Label_0040
this._currentStepIndex++;
error = application.ExecuteStep(this._execSteps[this._currentStepIndex], ref completedSynchronously);
goto Label_0040;
每执行完StepManager中_execSteps保存事件或httpHandler就+1 goto 到下一次的事件或httpHandler。
ExecuteStep调用了 step.Execute()，接着Execute又执行了HttpHandler的ProecessRequest方法。这个时候请求就直正交到了HttpHandler手里处理了。
以下HttpApplication管线执行先后顺序，订阅事件，HttpModule，HttpHanlder加载与执行位置（参照博文：ASP.NET MVC Preview生命周期分析）
HttpApplication 管线会依次处理下面的请求: -
对请求进行验证，将检查浏览器发送的信息，并确定其是否包含潜在恶意标记。
-
如果已在 Web.config 文件的 UrlMappingsSection 节中配置了任何 URL，则执行 URL 映射。
-
引发 BeginRequest 事件。
-
引发 AuthenticateRequest 事件。
-
引发 PostAuthenticateRequest 事件。
-
引发 AuthorizeRequest 事件。
-
引发 PostAuthorizeRequest 事件。
-
引发 ResolveRequestCache 事件。
-
引发 PostResolveRequestCache 事件。通知HttpModule根据请求选择对应的HttpHnadler加载至上下文中。
-
根据所请求资源的文件扩展名（在应用程序的配置文件中映射），选择实现 IHttpHandler 的类，对请求进行处理。如果该请求针对从 Page 类派生的对象（页），并且需要对该页进行编译，则 ASP.NET 会在创建该页的实例之前对其进行编译。（除了配置文件中的，还有上下文中的HttpHnadler）
-
引发 PostMapRequestHandler 事件。继续通知HttpModule确定要使用哪个HttpHandler用以处理请求。
-
引发 AcquireRequestState 事件。
-
引发 PostAcquireRequestState 事件。
-
引发 PreRequestHandlerExecute 事件。
-
为该请求调用合适的 IHttpHandler 类的 ProcessRequest 方法（或异步版 BeginProcessRequest）。例如，如果该请求针对某页，则当前的页实例将处理该请求。
-
引发 PostRequestHandlerExecute 事件。
-
引发 ReleaseRequestState 事件。
-
引发 PostReleaseRequestState 事件。
-
如果定义了 Filter 属性，则执行响应筛选。
-
引发 UpdateRequestCache 事件。
-
引发 PostUpdateRequestCache 事件。
-
引发 EndRequest 事件。
小结：
理一下前后的过程
ISAPIRuntime 调用至HttpRuntime ， HttpRuntime 通过HttpApplicationFactory 获取HttpApplication，HttpApplication在生成的同时加载了所有的HttpMoudule，并且通过StepManager完
成对管线事件绑定及HttpHandler的加载。然后HttpRuntime 触发HttpApplication 的BeginProcessRequest开始了真正的HttpRequest请求的处理过程。
HttpApplication按照管线StepManager事先设定好的事件触发顺序，当被HttpModule订阅的事件发生，HttpModule根据请求的信息加载对应的HttpHandler到上下文中，并把控制权还给管线。
HttpApplication继续按照管线进行，将所有的HttpHandler加载进来。之后过程中通过HttpModule确定使用哪个HttpHandler处理请求，直到管线调用这个 HttpHandler的ProcessRequest，这个时候HttpHandler才开始着手处理上下文中的请求，比如查找请求的具体页面地址，调用请求的方法，绘制视图等等。
HttpHandler 处理完后，HttpApplication管线又将上下文的控制交还给HttpModule，HttpModule对请求最后处理后，又把控制权还给管线继续处理下面的事件，直到HttpRuntime 结束请求返回客户端。
以上是为.net MVC 实现机制分析做的铺垫。
