ASP.NET初始化流程分析2

上一篇讲了从创建应用程序域到创建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来执行这些事件看看效果如何。

下面是总结一下处理第一次请求的大体处理流程。