深入ASP.NET MVC 之一：IIS到路由表
关于IIS的介绍，可以参考Introduction to IIS Architecture 。IIS到托管代码的入口点是位于System.Web dll中
public sealed class ISAPIRuntime : MarshalByRefObject, IISAPIRuntime, IISAPIRuntime2, IRegisteredObject
的方法
public int ProcessRequest(IntPtr ecb, int iWRType) { IntPtr intPtr = IntPtr.Zero; if (iWRType == 2) { intPtr = ecb; ecb = UnsafeNativeMethods.GetEcb(intPtr); } ISAPIWorkerRequest iSAPIWorkerRequest = null; int result; try { bool useOOP = iWRType == 1; iSAPIWorkerRequest = ISAPIWorkerRequest.CreateWorkerRequest(ecb, useOOP); iSAPIWorkerRequest.Initialize(); string appPathTranslated = iSAPIWorkerRequest.GetAppPathTranslated(); string appDomainAppPathInternal = HttpRuntime.AppDomainAppPathInternal; if (appDomainAppPathInternal == null || StringUtil.EqualsIgnoreCase(appPathTranslated, appDomainAppPathInternal)) { HttpRuntime.ProcessRequestNoDemand(iSAPIWorkerRequest); result = 0; } else { //……
} } catch (Exception ex) { //……
} return result; }
（注:IIS7的入口似乎是PipeLineRuntime.InitializeApplication(IntPtr appContext)，过程有所不同，但是不影响后面的流程）其中ecb是一个指向httprequest的信息的指针，由IIS提供。CreateWorkerRequest根据ecb提供的信息，比如IIS的版本、模式等，创建一个ISAPIWorkerRequest对象，ISAPIWorkerReuqeuest是一个http请求的.NET封装。创建好WorkerRequest之后，调用HttpRuntime.ProcessRequestNoDemand(iSAPIWorkerRequest);开始执行请求，这个方法是会从httpRuntime对象中的一个队列中获取一个workerrequest进行处理，最终调用的是HttpRuntime类中的ProcessRequestInternal（代码有删节）:
private void ProcessRequestInternal(HttpWorkerRequest wr) { Interlocked.Increment(ref this._activeRequestCount); if (this._disposingHttpRuntime) wr.SendStatus(503, "Server Too Busy"); HttpContext httpContext; try { httpContext = new HttpContext(wr, false); } catch { try { wr.SendStatus(400, "Bad Request"); //…….
} finally { Interlocked.Decrement(ref this._activeRequestCount); } } wr.SetEndOfSendNotification(this._asyncEndOfSendCallback, httpContext); HostingEnvironment.IncrementBusyCount(); try { httpContext.Response.InitResponseWriter(); IHttpHandler applicationInstance = HttpApplicationFactory.GetApplicationInstance(httpContext); if (applicationInstance == null) { throw new HttpException(SR.GetString("Unable_create_app_object")); } if (applicationInstance is IHttpAsyncHandler) { IHttpAsyncHandler httpAsyncHandler = (IHttpAsyncHandler)applicationInstance; httpContext.AsyncAppHandler = httpAsyncHandler; httpAsyncHandler.BeginProcessRequest(httpContext, this._handlerCompletionCallback, httpContext); } else { applicationInstance.ProcessRequest(httpContext); this.FinishRequest(httpContext.WorkerRequest, httpContext, null); } } catch (Exception e) { httpContext.Response.InitResponseWriter(); this.FinishRequest(wr, httpContext, e); } }
在这段代码中，HttpRuntime可以根据当前服务器的状况回送不同的Http状态码。如果一切正常，首先根据WorkerRequest创建了HttpContext，HttpApplication根据HttpContext创建了一个IHttpHandler对象,这是一个比较复杂的过程。先看代码：
internal static IHttpHandler GetApplicationInstance(HttpContext context) { if (HttpApplicationFactory._customApplication != null) { return HttpApplicationFactory._customApplication; } if (context.Request.IsDebuggingRequest) { return new HttpDebugHandler(); } HttpApplicationFactory._theApplicationFactory.EnsureInited(); HttpApplicationFactory._theApplicationFactory.EnsureAppStartCalled(context); return HttpApplicationFactory._theApplicationFactory.GetNormalApplicationInstance(context); }
customApplication应该是使用 ASP.NET State Service的时候的情况，DebugHandler应该是调试状态下的情况，不作深究，除此以外，一共有三大步骤，首先要确保调用且仅调用了一次 ApplicationFactory的Init方法，在这个方法中，主要完成了以下工作（代码有删节）：
private void Init() { this._appFilename = HttpApplicationFactory.GetApplicationFile(); this.CompileApplication(); }
其中GetApplicationFile为:
internal static string GetApplicationFile() { return Path.Combine(HttpRuntime.AppDomainAppPathInternal, "global.asax"); }
ASP.NET在这里关联上了global.asax .在CompileApplication方法中，除了回去编译ASP.NET项目中未编译的代码，还有两件重要的工作:
private void CompileApplication() { this._theApplicationType = BuildManager.GetGlobalAsaxType(); //Use BuilderManager to build code
this.ReflectOnApplicationType(); }
首先是设置了theApplicationType，比如默认情况下，一个ASP.NET MVC的applicationType将是 MvcApplication,也就是global.asax中那个类。ReflectOnApplicationType 代码如下：
private void ReflectOnApplicationType() { ArrayList arrayList = new ArrayList(); MethodInfo[] methods = this._theApplicationType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); MethodInfo[] array = methods; for (int i = 0; i < array.Length; i++) { MethodInfo methodInfo = array[i]; if (this.ReflectOnMethodInfoIfItLooksLikeEventHandler(methodInfo)) { arrayList.Add(methodInfo); } } Type baseType = this._theApplicationType.BaseType; if (baseType != null && baseType != typeof(HttpApplication)) { methods = baseType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic); MethodInfo[] array2 = methods; for (int j = 0; j < array2.Length; j++) { MethodInfo methodInfo2 = array2[j]; if (methodInfo2.IsPrivate && this.ReflectOnMethodInfoIfItLooksLikeEventHandler(methodInfo2)) { arrayList.Add(methodInfo2); } } } this._eventHandlerMethods = new MethodInfo[arrayList.Count]; for (int k = 0; k < this._eventHandlerMethods.Length; k++) { this._eventHandlerMethods[k] = (MethodInfo)arrayList[k]; } }
简单来说，这个方法反射了global.asax中的那个类，并且将里面的类似于EventHandler的方法放到this._eventHandlerMethods中。
例如,ReflectOnMethodInfoIfItLooksLikeEventHandler中的代码片段:
if (StringUtil.EqualsIgnoreCase(name, "Application_OnStart") || StringUtil.EqualsIgnoreCase(name, "Application_Start")) { this._onStartMethod = m; this._onStartParamCount = parameters.Length; }
确保ApplicationFactory的Init被调用过之后，接下来，要保证Global.asax中的App_Start被调用。EnsureAppStartCalled 的核心代码就是调用了this._onStartMethod,这个方法在上面介绍Init方法中已经被初始化好。EnsureAppStartCalled做的事情虽然简单，但是其实现还是挺繁琐的，估计是为了线程安全性等考虑，不再分析其具体实现。最后，就是真正的获取一个ApplicationHandler的方法了：
private HttpApplication GetNormalApplicationInstance(HttpContext context) { HttpApplication httpApplication = null; lock (this._freeList) { if (this._numFreeAppInstances > 0) { httpApplication = (HttpApplication)this._freeList.Pop(); this._numFreeAppInstances--; if (this._numFreeAppInstances < this._minFreeAppInstances) { this._minFreeAppInstances = this._numFreeAppInstances; } } } if (httpApplication == null) { httpApplication = (HttpApplication)HttpRuntime.CreateNonPublicInstance(this._theApplicationType); using (new ApplicationImpersonationContext()) { httpApplication.InitInternal(context, this._state, this._eventHandlerMethods); } } if (AppSettings.UseTaskFriendlySynchronizationContext) { httpApplication.ApplicationInstanceConsumersCounter = new CountdownTask(1); httpApplication.ApplicationInstanceConsumersCounter.Task.ContinueWith(delegate(Task _, object o) { HttpApplicationFactory.RecycleApplicationInstance((HttpApplication)o); }, httpApplication, TaskContinuationOptions.ExecuteSynchronously); } return httpApplication; }
可以看到，首先可用的HttpApplication都是缓存在一个List中的，如果没有可用的HttpApplication，则会根据theApplicationType来创建一个，核心方法是调用InitInternal方法，注意到最后一个参数是this._eventHandlerMethods，这就是global.asax中的各个EventHandler。InitInternal方法也是一个比较复杂的方法，里面对于IIS采用的是Integrated模式还是Classic模式进行分别的处理，主要完成的工作时HttpModule的初始化和处理请求过程中每个步骤触发事件处理程序的准备。先看Integrate模式下Module的初始化:
private void InitIntegratedModules() { this._moduleCollection = this.BuildIntegratedModuleCollection(HttpApplication._moduleConfigInfo); this.InitModulesCommon(); }
第一步是根据配置的Module名字实例化Module对象，第二步代码如下：
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(); }注意加粗的代码，它调用了IHttpModule的Init方法。这是ASP.NET挂载Module关键之处。接下来看
public class UrlRoutingModule : IHttpModule
这个类的Init实现。这个HttpModule是实现URL路由的关键。在.NET 4之前它是位于System.Web.Routing.dll之中的，.NET 4之后它已经被合并入System.Web.dll中了成为了Asp.NET不可分割的一部分。
protected virtual void Init(HttpApplication application) { if (application.Context.Items[UrlRoutingModule._contextKey] != null) { return; } application.Context.Items[UrlRoutingModule._contextKey] = UrlRoutingModule._contextKey; application.PostResolveRequestCache += new EventHandler(this.OnApplicationPostResolveRequestCache); }
最核心的代码是最后一行，它注册了 PostResolveRequestCache事件的响应程序OnApplicationPostResolveRequestCache。 响应程序的核心代码如下:
public virtual void PostResolveRequestCache(HttpContextBase context) { RouteData routeData = this.RouteCollection.GetRouteData(context); if (routeData == null) { return; } IRouteHandler routeHandler = routeData.RouteHandler; if (routeHandler == null) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, SR.GetString("UrlRoutingModule_NoRouteHandler"), new object[0])); } if (routeHandler is StopRoutingHandler) { return; } 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)) { context.RemapHandler(httpHandler); return; } if (FormsAuthenticationModule.FormsAuthRequired) { UrlAuthorizationModule.ReportUrlAuthorizationFailure(HttpContext.Current, this); return; } throw new HttpException(401, SR.GetString("Assess_Denied_Description3")); }
在这里，代码根据RouteData获得RouteHandler,RouteHandler获得HttpHandler。这里的详情下文再分析，至此，一个HTTP请求将会通过IIS传递到路由模块了。下面再会这段代码何时会被触发。先回到InitInternal方法中第二项工作，也就是处理请求过程中每个步骤触发事件处理程序的准备。ASP.NET首先定义了一个枚举来表示处理一个request的处理周期
public enum RequestNotification { BeginRequest = 1, AuthenticateRequest = 2, AuthorizeRequest = 4, ResolveRequestCache = 8, MapRequestHandler = 16, AcquireRequestState = 32, PreExecuteRequestHandler = 64, ExecuteRequestHandler = 128, ReleaseRequestState = 256, UpdateRequestCache = 512, LogRequest = 1024, EndRequest = 2048, SendResponse = 536870912 }
在InitInternal中，InitModule完成之后紧接着调用了
private void HookupEventHandlersForApplicationAndModules(MethodInfo[] handlers)
这个方法的作用是将Global.asax中的方法（事件响应）加到合适的事件上，这里的事件可以是各个HttpModule的事件。实际上就是根据命名规则去找到相应的HttpModule的事件。这部分的实现也是很有技巧性，本文不多做分析，可以参考 http://aspnetresources.com/articles/event_handlers_in_global_asax 。 再接下来，InitInternal实例化了一个StepManager，同样有Integrate和Classic的两种，下面以Integrate的PipelStepManager为例,紧接着调用了StepManager的BuildStep方法:
internal override void BuildSteps(WaitCallback stepCallback) { HttpApplication application = this._application; HttpApplication.IExecutionStep step = new HttpApplication.MaterializeHandlerExecutionStep(application); application.AddEventMapping("ManagedPipelineHandler", RequestNotification.MapRequestHandler, false, step); application.AddEventMapping("ManagedPipelineHandler", RequestNotification.ExecuteRequestHandler, false, application.CreateImplicitAsyncPreloadExecutionStep()); HttpApplication.IExecutionStep step2 = new HttpApplication.CallHandlerExecutionStep(application); application.AddEventMapping("ManagedPipelineHandler", RequestNotification.ExecuteRequestHandler, false, step2); HttpApplication.IExecutionStep step3 = new HttpApplication.TransitionToWebSocketsExecutionStep(application); application.AddEventMapping("ManagedPipelineHandler", RequestNotification.EndRequest, true, step3); HttpApplication.IExecutionStep step4 = new HttpApplication.CallFilterExecutionStep(application); application.AddEventMapping("AspNetFilterModule", RequestNotification.UpdateRequestCache, false, step4); application.AddEventMapping("AspNetFilterModule", RequestNotification.LogRequest, false, step4); this._resumeStepsWaitCallback = stepCallback; }
这里面实例化了很多具体的IExecutionStep对象，并且和RequestNotification关联起来。这些step将是完成一个request的必要步骤。AddEventMapping的核心代码如下：
PipelineModuleStepContainer moduleContainer = this.GetModuleContainer(moduleName); if (moduleContainer != null) { moduleContainer.AddEvent(requestNotification, isPostNotification, step); }
moduleContainer 中有一个IExecutionStep列表，里面的step是按照requestNotification的顺序排列的，这点非常重要。至此,InitInternal的工作基本完成了。HttpApplication的一个实例也已经初始化完毕，直接跳回至ProccessRequestInternal方法，接下来就是调用BeginProcessRequest开始真正的处理了。这个方法的核心是调用 StepManager的ResumeSteps方法。更具体的，对于使用Integrated模式的ASP.NET的项目来说，是调用了PipelineStepManager的ResumeSteps方法。这个方法也很复杂，但是核心的代码就是两行:
HttpApplication.IExecutionStep nextEvent = this._application.CurrentModuleContainer.GetNextEvent(context.CurrentNotification, context.IsPostNotification, context.CurrentModuleEventIndex); error = this._application.ExecuteStep(nextEvent, ref flag3);
也就是从PipelineModuleStepContainer中取出准备好的step逐个执行。本文不再分析每个step的具体内容，有了以上的准备，接下来看本文的主题，routing module是什么时候被执行的。 回到上面routing module的Init方法中注册事件的方法，其内部实现是：
public event EventHandler PostResolveRequestCache { add { this.AddSyncEventHookup(HttpApplication.EventPostResolveRequestCache, value, RequestNotification.ResolveRequestCache, true); } remove { this.RemoveSyncEventHookup(HttpApplication.EventPostResolveRequestCache, value, RequestNotification.ResolveRequestCache, true); } }
AddSyncEventHookup的核心代码如下：
PipelineModuleStepContainer moduleContainer = this.GetModuleContainer(this.CurrentModuleCollectionKey); if (moduleContainer != null) { HttpApplication.SyncEventExecutionStep step = new HttpApplication.SyncEventExecutionStep(this, (EventHandler)handler); moduleContainer.AddEvent(notification, isPostNotification, step); }
在这里，他添加了一个SyncEventExecutionStep到moduleContainer中，因此，在执行到HttpApplication.EventPostResolveRequestCache的step的时候，SyncEventExecutionStep的Execute方法将被执行，这个方法的核心代码是:
this._handler(this._application, this._application.AppEvent);
这里的_handler，将会是new EventHandler(this.OnApplicationPostResolveRequestCache); _application是HttpApplication实例。
因此，routing module的代码就被执行了。
小结：本文大致分析了System.Web中的源代码，以asp.net中一个request的生命周期是如何的，介绍了routing module是怎样挂载到这个处理流程中的。Routing module只是一个普通的http module，其他的http module原理类似。下文将重点介绍routing module是如何工作的。
