深入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是如何工作的。