上一篇讲了从创建应用程序域到创建ISAPIRuntime实例的过程，本篇继续讲Asp.net处理第一次请求的必要的初始化过程。
ISAPIRuntime分析
ISAPIRuntime在System.Web.Hosting中实现，它的ProcessRequest是我们处理web请求的入口。
public int ProcessRequest(IntPtr ecb, int iWRType) {
IntPtr pHttpCompletion = IntPtr.Zero;
if (iWRType == WORKER_REQUEST_TYPE_IN_PROC_VERSION_2) {
pHttpCompletion = ecb;
ecb = UnsafeNativeMethods.GetEcb(pHttpCompletion);
}
ISAPIWorkerRequest wr = null;
try {
bool useOOP = (iWRType == WORKER_REQUEST_TYPE_OOP);
wr = ISAPIWorkerRequest.CreateWorkerRequest(ecb, useOOP);
wr.Initialize();
String wrPath = wr.GetAppPathTranslated();
String adPath = HttpRuntime.AppDomainAppPathInternal;
if (adPath == null ||StringUtil.EqualsIgnoreCase(wrPath, adPath)) {
HttpRuntime.ProcessRequestNoDemand(wr);
return ;
}
else {
HttpRuntime.ShutdownAppDomain(ApplicationShutdownReason.PhysicalApplicationPathChanged, SR.GetString(SR.Hosting_Phys_Path_Changed, adPath, wrPath));
return ;
}
}
catch(Exception e) {
try {
WebBaseEvent.RaiseRuntimeError(e, this);
} catch {}
if (wr != null && wr.Ecb == IntPtr.Zero) {
if (pHttpCompletion != IntPtr.Zero) {
UnsafeNativeMethods.SetDoneWithSessionCalled(pHttpCompletion);
}
if (e is ThreadAbortException) {
Thread.ResetAbort();
}
return ;
}
throw;
}
}
注意方法的IntPtr类型的参数ecb， 它是一个非托管的指针，用于传递一些必须的数据，以及最终将Response的内容返回给非托管环境ISAPI（异步方式），然后呈现给Client用户。方法中调用ISAPIWorkerRequest的静态方法CreateWorkerRequest而创建ISAPIWorkerRequest对象实例，参数分别为ecb和代表WorkerRequest类型的int参数iWRType，通过判断ecb和type类型的具体内容，来决定创建什么类型的WorkerRequest（上述类型的ISPAIWorkerRequest都继承于HttpWorkerRequest），上面的代码可以看出对不同版本的IIS进行了不同的包装，通过其Initialize方法来初始化一些基本的信息（比如：contentType, querystring的长度，filepath等相关信息）。然后调用HttpRuntime.ProcessRequestNoDemand(wr)转入HttpRuntime处理请求，最终体现在调用ProcessRequestInternal方法上。
HttpRuntime分析
Httpruntime在System.Web下实现，我们来看其处理请求的ProcessRequestInternal方法。
private void ProcessRequestInternal(HttpWorkerRequest wr) {
Interlocked.Increment(ref _activeRequestCount);
if (_disposingHttpRuntime) {
try {
wr.SendStatus(, "Server Too Busy");
wr.SendKnownResponseHeader(HttpWorkerRequest.HeaderContentType, "text/html; charset=utf-8");
byte[] body = Encoding.ASCII.GetBytes("<html><body>Server Too Busy</body></html>");
wr.SendResponseFromMemory(body, body.Length);
wr.FlushResponse(true);
wr.EndOfRequest();
} finally {
Interlocked.Decrement(ref _activeRequestCount);
}
return;
}
HttpContext context;
try {
context = new HttpContext(wr, false);
}
catch {
try {
wr.SendStatus(, "Bad Request");
wr.SendKnownResponseHeader(HttpWorkerRequest.HeaderContentType, "text/html; charset=utf-8");
byte[] body = Encoding.ASCII.GetBytes("<html><body>Bad Request</body></html>");
wr.SendResponseFromMemory(body, body.Length);
wr.FlushResponse(true);
wr.EndOfRequest();
return;
} finally {
Interlocked.Decrement(ref _activeRequestCount);
}
}
wr.SetEndOfSendNotification(_asyncEndOfSendCallback, context);
HostingEnvironment.IncrementBusyCount();
try {
try {
EnsureFirstRequestInit(context);
}
catch {
if (!context.Request.IsDebuggingRequest) {
throw;
}
}
context.Response.InitResponseWriter();
IHttpHandler app = HttpApplicationFactory.GetApplicationInstance(context);
if (app == null)
throw new HttpException(SR.GetString(SR.Unable_create_app_object));
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_START_HANDLER, context.WorkerRequest, app.GetType().FullName, "Start");
if (app is IHttpAsyncHandler) {
IHttpAsyncHandler asyncHandler = (IHttpAsyncHandler)app;
context.AsyncAppHandler = asyncHandler;
asyncHandler.BeginProcessRequest(context, _handlerCompletionCallback, context);
}
else {
app.ProcessRequest(context);
FinishRequest(context.WorkerRequest, context, null);
}
}
catch (Exception e) {
context.Response.InitResponseWriter();
FinishRequest(wr, context, e);
}
}
该方法中创建了熟悉的HttpContext并同时创建了HttpRequest与HttpResponse
internal HttpContext(HttpWorkerRequest wr, bool initResponseWriter) {
_wr = wr;
Init(new HttpRequest(wr, this), new HttpResponse(wr, this));
if (initResponseWriter)
_response.InitResponseWriter();
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_EXECUTING);
}
然后通过HttpApplicationFactory的GetApplicationInstance静态方法，获取我们熟悉的HttpApplication对象实例（注：HttpApplication对象是继承IHttpAsyncHandler，而IHttpAsyncHandler又继承于IHttpHandler），然后执行调用BeginProcessRequest方法。至此正式进入了HttpApplication对象的创建以及大家熟知的HttpApplication以后的生命周期了。
HttpApplicationFactory分析
HttpApplicationFactory在System.Web下实现。
查看HttpApplicationFactory用来创建Httpapplication的GetApplicationInstance方法。
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);
}
该方法有三个步骤：首先是EnsureInited，会检查是否已经初始化，如果没有会调用Init方法先获取global.asax文件的完整路径，然后调用CompileApplication()对global.asax进行编译，Init方法如下。
private void Init() {
if (_customApplication != null)
return;
try {
try {
_appFilename = GetApplicationFile();
CompileApplication();
}
finally {
SetupChangesMonitor();
}
}
catch {
throw;
}
}
然后是EnsureAppStartCalled方法如果未开始启动会调用FireApplicationOnStart。
private void EnsureAppStartCalled(HttpContext context) {
if (!_appOnStartCalled) {
lock (this) {
if (!_appOnStartCalled) {
using (new DisposableHttpContextWrapper(context)) {
WebBaseEvent.RaiseSystemEvent(this, WebEventCodes.ApplicationStart);
FireApplicationOnStart(context);
}
_appOnStartCalled = true;
}
}
}
}
private void FireApplicationOnStart(HttpContext context) {
if (_onStartMethod != null) {
HttpApplication app = GetSpecialApplicationInstance();
app.ProcessSpecialRequest(context, _onStartMethod, _onStartParamCount, this, EventArgs.Empty, null);
RecycleSpecialApplicationInstance(app);
}
}
这里创建特定的HttpApplication实例，触发ApplicationOnStart事件(会执行global.asax中的Application_Start方法)。然后在处理完事件以后就立即被回收掉，因为系统初始化只需要一次。
最后是GetNormalApplicationInstance，如果在有空闲的HttpApplication实例，就直接用，如果没有就新创建，然后调用InitInternal方法进行初始化相关的内容，最后返回该HttpApplication实例。
private HttpApplication GetNormalApplicationInstance(HttpContext context) {
HttpApplication app = null;
lock (_freeList) {
if (_numFreeAppInstances > ) {
app = (HttpApplication)_freeList.Pop();
_numFreeAppInstances--;
if (_numFreeAppInstances < _minFreeAppInstances) {
_minFreeAppInstances = _numFreeAppInstances;
}
}
}
if (app == null) {
app = (HttpApplication)HttpRuntime.CreateNonPublicInstance(_theApplicationType);
using (new ApplicationImpersonationContext()) {
app.InitInternal(context, _state, _eventHandlerMethods);
}
}
……
return app;
}
HttpApplication分析
HttpApplication在System.Web下实现，首先查看HttpApplication的InitInternal方法，该方法用于初始化。
internal void InitInternal(HttpContext context, HttpApplicationState state, MethodInfo[] handlers) {
Debug.Assert(context != null, "context != null");
_state = state;
PerfCounters.IncrementCounter(AppPerfCounter.PIPELINES);
try {
try {
_initContext = context;
_initContext.ApplicationInstance = this;
context.ConfigurationPath = context.Request.ApplicationPathObject;
using (new DisposableHttpContextWrapper(context)) {
if (HttpRuntime.UseIntegratedPipeline) {
Debug.Assert(_moduleConfigInfo != null, "_moduleConfigInfo != null");
Debug.Assert(_moduleConfigInfo.Count >= , "_moduleConfigInfo.Count >= 0");
try {
context.HideRequestResponse = true;
_hideRequestResponse = true;
InitIntegratedModules();
}
finally {
context.HideRequestResponse = false;
_hideRequestResponse = false;
}
}
else {
InitModules();
Debug.Assert(null == _moduleContainers, "null == _moduleContainers");
}
if (handlers != null)
HookupEventHandlersForApplicationAndModules(handlers);
_context = context;
if (HttpRuntime.UseIntegratedPipeline && _context != null) {
_context.HideRequestResponse = true;
}
_hideRequestResponse = true;
try {
Init();
}
catch (Exception e) {
RecordError(e);
}
}
if (HttpRuntime.UseIntegratedPipeline && _context != null) {
_context.HideRequestResponse = false;
}
_hideRequestResponse = false;
_context = null;
_resumeStepsWaitCallback= new WaitCallback(this.ResumeStepsWaitCallback);
if (HttpRuntime.UseIntegratedPipeline) {
_stepManager = new PipelineStepManager(this);
}
else {
_stepManager = new ApplicationStepManager(this);
}
_stepManager.BuildSteps(_resumeStepsWaitCallback);
}
finally {
_initInternalCompleted = true;
context.ConfigurationPath = null;
_initContext.ApplicationInstance = null;
_initContext = null;
}
}
catch {
throw;
}
}
该代码主要有2个功能，一个是初始化大家熟悉的HttpModules，一个是通过BuildSteps执行多个生命周期事件的处理函数。通过上面的代码我们可以看出，每个功能都有一个特殊判断，判断IIS是否是IIS7的集成模式，如果是就有特殊的步骤，如果不是就走一般的步骤（两者直接的差异分别是：经典模式初始化HttpModules的时候会从网站配置的Modules里读取，集成模式会预加载CLR和大量Modules，比如加载服务器上设置的HttpModules；另外在BuildSteps的时候， IIS7集成模式走的是自己特殊的流程）。
总结一下，InitInternal方法的主要功能如下：
InitModules()：根据Web.Config的设置，加载相应的HttpModules。
InitIntegratedModules()：会加载IIS7集成模式下在服务器上设定的HttpModuels和Web.config里system.webserver下的HttpModuels。
HookupEventHandlersForAppplicationAndModules：绑定HttpApplication实例中相应的事件处理函数（在Global.asax中定义的事件处理函数）。
创建很多实现IExecutionStep接口的类的实例并添加到当前HttpApplication实例的_execSteps中（包括HttpModules中定义的周期事件处理函数和查找匹配的HttpHandler、执行HttpHandler的方法以及过滤输出等特殊事件），等待回调时执行。从这里我们可以看到HttpApplication是以异步的方式处理请求， 对请求的很多处理工作都放入了_execStep等待回调时执行。
在 HttpApplication的事件如下形式定义：
public event EventHandler BeginRequest {
add { AddSyncEventHookup(EventBeginRequest, value, RequestNotification.BeginRequest); }
remove { RemoveSyncEventHookup(EventBeginRequest, value, RequestNotification.BeginRequest); }
}
所有的事件都是调用AddSyncEventHookup方法添加进去的，其中第一个参数是以Event+事件名称的值。
internal void AddSyncEventHookup(object key, Delegate handler, RequestNotification notification) {
AddSyncEventHookup(key, handler, notification, false);
}
private void AddSyncEventHookup(object key, Delegate handler, RequestNotification notification, bool isPostNotification) {
ThrowIfEventBindingDisallowed();
Events.AddHandler(key, handler);
if (IsContainerInitalizationAllowed) {
PipelineModuleStepContainer container = GetModuleContainer(CurrentModuleCollectionKey);
if (container != null) {
SyncEventExecutionStep step = new SyncEventExecutionStep(this, (EventHandler)handler);
container.AddEvent(notification, isPostNotification, step);
}
}
}
经典模式下在初始化HttpModlue的时候通过调用Events.AddHandler方法，将事件添加到Events集合里，同时这个key就是Event+事件名称，而集成模式下这些事件是添加到另外一个地方的（通过将事件hanlder包装成SyncEventExecutionStep类型，然后调用container.AddEvent方法将事件添加到另外一个地方），也就是说if上面的Events集合是给经典模式用的，下面的Container里的数据是给集成模式用的，这些事件是存放在HttpApplication的ModuleContainers属性里，这个属性的类型是PipelineModuleStepContainer[]，个数就是HttpModules的个数，也就是说每个HttpModule在HttpApplication上添加的事件都放在各自的PipelineModuleStepContainer容器里。
private PipelineModuleStepContainer[] ModuleContainers {
get {
if (_moduleContainers == null) {
Debug.Assert(_moduleIndexMap != null && _moduleIndexMap.Count > , "_moduleIndexMap != null && _moduleIndexMap.Count > 0");
_moduleContainers = new PipelineModuleStepContainer[_moduleIndexMap.Count];
for (int i = ; i < _moduleContainers.Length; i++) {
_moduleContainers[i] = new PipelineModuleStepContainer();
}
}
return _moduleContainers;
}
}
StepManager分析
集成模式和经典模式（或IIS6）使用的是不同的StepManager，这个类的BuildSteps方法就是为了创建有序的ExecutionStep，其中包括各种事件的事情以及其它在各时间周期之间穿插的操作，最主要的操作，大家以前就应该知道的，比如哪个周期可以判定使用哪个HttpHandler，以及在哪个周期内执行这个HttpHandler的BeginProcessRequest方法。StepManager的具体实现类（ApplicationStepManager、PipelineStepManager）和HttpApplication类在同一个文件中定义。
ApplicationStepManager的BuildSteps方法（用于经典模式）
internal override void BuildSteps(WaitCallback stepCallback ) {
ArrayList steps = new ArrayList();
HttpApplication app = _application;
bool urlMappingsEnabled = false;
UrlMappingsSection urlMappings = RuntimeConfig.GetConfig().UrlMappings;
urlMappingsEnabled = urlMappings.IsEnabled && ( urlMappings.UrlMappings.Count > );
steps.Add(new ValidateRequestExecutionStep(app));
steps.Add(new ValidatePathExecutionStep(app));
if (urlMappingsEnabled)
steps.Add(new UrlMappingsExecutionStep(app)); // url mappings
app.CreateEventExecutionSteps(HttpApplication.EventBeginRequest, steps);
app.CreateEventExecutionSteps(HttpApplication.EventAuthenticateRequest, steps);
app.CreateEventExecutionSteps(HttpApplication.EventDefaultAuthentication, steps);
app.CreateEventExecutionSteps(HttpApplication.EventPostAuthenticateRequest, steps);
app.CreateEventExecutionSteps(HttpApplication.EventAuthorizeRequest, steps);
app.CreateEventExecutionSteps(HttpApplication.EventPostAuthorizeRequest, steps);
app.CreateEventExecutionSteps(HttpApplication.EventResolveRequestCache, steps);
app.CreateEventExecutionSteps(HttpApplication.EventPostResolveRequestCache, steps);
steps.Add(new MapHandlerExecutionStep(app)); // map handler
app.CreateEventExecutionSteps(HttpApplication.EventPostMapRequestHandler, steps);
app.CreateEventExecutionSteps(HttpApplication.EventAcquireRequestState, steps);
app.CreateEventExecutionSteps(HttpApplication.EventPostAcquireRequestState, steps);
app.CreateEventExecutionSteps(HttpApplication.EventPreRequestHandlerExecute, steps);
steps.Add(app.CreateImplicitAsyncPreloadExecutionStep());
steps.Add(new CallHandlerExecutionStep(app)); // execute handler
app.CreateEventExecutionSteps(HttpApplication.EventPostRequestHandlerExecute, steps);
app.CreateEventExecutionSteps(HttpApplication.EventReleaseRequestState, steps);
app.CreateEventExecutionSteps(HttpApplication.EventPostReleaseRequestState, steps);
steps.Add(new CallFilterExecutionStep(app)); // filtering
app.CreateEventExecutionSteps(HttpApplication.EventUpdateRequestCache, steps);
app.CreateEventExecutionSteps(HttpApplication.EventPostUpdateRequestCache, steps);
_endRequestStepIndex = steps.Count;
app.CreateEventExecutionSteps(HttpApplication.EventEndRequest, steps);
steps.Add(new NoopExecutionStep()); // the last is always there
_execSteps = new IExecutionStep[steps.Count];
steps.CopyTo(_execSteps);
_resumeStepsWaitCallback = stepCallback;
}
private void CreateEventExecutionSteps(Object eventIndex, ArrayList steps) {
AsyncAppEventHandler asyncHandler = AsyncEvents[eventIndex];
if (asyncHandler != null) {
asyncHandler.CreateExecutionSteps(this, steps);
}
EventHandler handler = (EventHandler)Events[eventIndex];
if (handler != null) {
Delegate[] handlers = handler.GetInvocationList();
for (int i = ; i < handlers.Length; i++) {
steps.Add(new SyncEventExecutionStep(this, (EventHandler)handlers[i]));
}
}
}
这个方法的完整功能归纳总结有以下几点：
对请求的Request进行验证，ValidateRequestExecutionStep。
对请求的路径进行安全检查，禁止非法路径访问(ValidatePathExecutionStep)。
如果设置了UrlMappings, 进行RewritePath(UrlMappingsExecutionStep)。
执行事件处理函数，比如将BeginRequest、AuthenticateRequest转化成可执行ExecutionStep在正式调用时候执行。
在这多个个事件操作处理期间，根据不同的时机加了4个特殊的ExecutionStep。
MapHandlerExecutionStep：查找匹配的HttpHandler
CallHandlerExecutionStep：执行HttpHandler的BeginProcessRequest
CallFilterExecutionStep：调用Response.FilterOutput方法过滤输出
NoopExecutionStep：空操作，留着以后扩展用
所有的ExecuteionStep都保存在ApplicationStepManager实例下的私有字段_execSteps里，而HttpApplication的BeginProcessRequest方法最终会通过该实例的ResumeSteps方法来执行这些操作。
PipelineStepManager的BuildSteps（用于集成模式）
internal override void BuildSteps(WaitCallback stepCallback) {
Debug.Trace("PipelineRuntime", "BuildSteps");
HttpApplication app = _application;
IExecutionStep materializeStep = new MaterializeHandlerExecutionStep(app);
app.AddEventMapping(ttpApplication.IMPLICIT_HANDLER,
RequestNotification.MapRequestHandler,
false, materializeStep);
app.AddEventMapping(HttpApplication.IMPLICIT_HANDLER,
RequestNotification.ExecuteRequestHandler,
false, app.CreateImplicitAsyncPreloadExecutionStep());
IExecutionStep handlerStep = new CallHandlerExecutionStep(app);
app.AddEventMapping(HttpApplication.IMPLICIT_HANDLER,
RequestNotification.ExecuteRequestHandler,
false, handlerStep);
IExecutionStep webSocketsStep = new TransitionToWebSocketsExecutionStep(app);
app.AddEventMapping(HttpApplication.IMPLICIT_HANDLER,
RequestNotification.EndRequest,
true, webSocketsStep);
IExecutionStep filterStep = new CallFilterExecutionStep(app);
app.AddEventMapping(HttpApplication.IMPLICIT_FILTER_MODULE,
RequestNotification.UpdateRequestCache,
false, filterStep);
app.AddEventMapping(HttpApplication.IMPLICIT_FILTER_MODULE,
RequestNotification.LogRequest,
false, filterStep);
_resumeStepsWaitCallback = stepCallback;
}
private void AddEventMapping(string moduleName,RequestNotification requestNotification, bool isPostNotification,IExecutionStep step) {
......
PipelineModuleStepContainer container = GetModuleContainer(moduleName);
container.AddEvent(requestNotification, isPostNotification, step);
}
以上代码有2个地方和经典模式不相同：
集成模式没有使用MapHandlerExecutionStep来装载ExecutionStep（也就是查找对应的HttpHandler），而是通过MaterializeHandlerExecutionStep类来获得HttpHandler，方式不一样。
集成模式是通过HttpApplication的AddEventMapping方法来添加事件的，从而将事件加入到前面所说的ModuleContainers容器。
总结一下，在经典模式下，是用 Event+事件名称做key将所有事件的保存在HttpApplication的Events属性对象里，然后在BuildSteps里统一按照顺序组装，中间加载4个特殊的ExecutionStep，最后在统一执行；在集成模式下，是通过HttpModule名称+RequestNotification枚举值作为key将所有的事件保存在HttpApplication的ModuleContainers属性对象里，然后也在BuildSteps里通过伪造HttpModule名称加载那4个特殊的ExecutionStep，最后按照枚举类型的顺序，遍历所有的HttpModule按顺序来执行这些事件，可以自行编写一个自定义的HttpModuel来执行这些事件看看效果如何。
下面是总结一下处理第一次请求的大体处理流程。