Asp.Net 详解IIS内部运行原理

最新推荐文章于 2023-10-27 17:00:00 发布
最新推荐文章于 2023-10-27 17:00:00 发布
阅读量605 收藏
点赞数
分类专栏： IIS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28960147/article/details/80964534
版权

Asp.Net 详解IIS内部运行原理

本章节主要讲IIS和Asp.Net 管道内部如何处理客户端Http请求，会较多的以代码的形式讲述，让大家对HttpApplication、HttpHandler、HttpApplicationFactory、Page这几个在处理请求过程中扮演重要角色的对象有更深入的了解。


我们都知道，当用户在浏览器地址栏中输入网址时，该请求会被IIS服务器捕获，如果是请求的是静态页面则由IIS本身处理并直接返回客户端，如果是动态页（*.aspx），通过一序列的前期(这部分处理过程本文不详细讲解，可以参考其他文章)的处理来到.NET运行时，然后交给Aspnet_ispai.dll处理，处理完成后返回处理结果。请求和处理过程可以分为：HttpRuntime->HttpModule->HtppApplicationFactory->HttpApplication->HttpHandlerFactory->HttpHandler->HttpModule->将请求结果返回到客户端。


下面我们通过单步调式跟踪System.Web.Dll源码来分析各个过程中关键处理函数(关于如何单步调式.Net FrameWork 源码我将在后面的文章中给出)

（说明：部分代码只保留了关键代码）


1、首先进入管道运行时中的托管入口函数

IIS集成模式：

在IPipelineRuntime.cs类中请求通知函数：ProcessRequestNotification，并调用ProcessRequestNotificationHelper函数

  1. internal static int ProcessRequestNotification(
  2. IntPtr rootedObjectsPointer,
  3. IntPtr nativeRequestContext,
  4. IntPtr moduleData,
  5. int flags)
  6. {
  7. try {
  8. //调用ProcessRequestNotificationHelper
  9.   return ProcessRequestNotificationHelper(rootedObjectsPointer, nativeRequestContext, moduleData, flags);
  10. }
  11. catch(Exception e) {
  12. ApplicationManager.RecordFatalException(e);
  13. throw;
  14. }
  15. }

2、在ProcessRequestNotificationHelper函数中调用运行时HttpRuntime中的ProcessRequestNotification函数

  1. internal static int ProcessRequestNotificationHelper(
  2. IntPtr rootedObjectsPointer,
  3. IntPtr nativeRequestContext,
  4. IntPtr moduleData,
  5. int flags)
  6. {
  7. IIS7WorkerRequest wr = null;
  8. HttpContext context = null;
  9. RequestNotificationStatus status = RequestNotificationStatus.Continue;
  10. RootedObjects root;
  11. bool workerRequestWasJustCreated = false;
  13. try {
  15. status = HttpRuntime.ProcessRequestNotification(wr, context); //调用ProcessRequestNotification函数
  16. }
  17. finally {
  19. }
  20. return ( int)status;
  22. }

3、在ProcessRequestNotification中调用ProcessRequestNotificationPrivate

4、处理请求通知ProcessRequestNotificationPrivate函数中调用了HttpApplicatioinFactory的GetApplicationInstance()函数来获取HttpApplication实例对象，并调用BeginProcessRequestNotification处理请求

  1. private RequestNotificationStatus ProcessRequestNotificationPrivate(IIS7WorkerRequest wr, HttpContext context) {
  2. RequestNotificationStatus status = RequestNotificationStatus.Pending;
  3. try {
  6. IHttpHandler handler = null;
  7. if (context.NeedToInitializeApp()) {
  9. try {
  10. EnsureFirstRequestInit(context);
  11. }
  12. catch {
  14. }
  16. context.Response.InitResponseWriter();
  17. handler = HttpApplicationFactory.GetApplicationInstance(context); //获取HttpApplication实例
  18. if (handler == null)
  19. throw new HttpException(SR.GetString(SR.Unable_create_app_object));
  21. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_START_HANDLER, context.WorkerRequest, handler.GetType().FullName, "Start");
  23. HttpApplication app = handler as HttpApplication;
  24. if (app != null) {
  25. // associate the context with an application instance
  26. app.AssignContext(context);
  27. }
  28. }
  31. wr.SynchronizeVariables(context);
  33. if (context.ApplicationInstance != null) {
  34. // 处理请求
  35. IAsyncResult ar = context.ApplicationInstance.BeginProcessRequestNotification(context, _requestNotificationCompletionCallback);
  37. if (ar.CompletedSynchronously) {
  38. status = RequestNotificationStatus.Continue;
  39. }
  40. }
  41. else if (handler != null) {
  42. // HttpDebugHandler is processed here
  43. handler.ProcessRequest(context);
  44. status = RequestNotificationStatus.FinishRequest;
  45. }
  46. else {
  47. status = RequestNotificationStatus.Continue;
  48. }
  49. }
  50. catch (Exception e) {
  52. }
  53. return status;
  54. }

IIS经典模式：

在ISAPIRuntime.cs类中请求 ProcessRequest函数并调用HttpRuntime.ProcessReques方法

1、HttpRuntime处理请求入口函数

  1. public static void ProcessRequest(HttpWorkerRequest wr) {
  2. if (wr == null)
  3. throw new ArgumentNullException( "wr");
  5. if (HttpRuntime.UseIntegratedPipeline) {
  6. throw new PlatformNotSupportedException(SR.GetString(SR.Method_Not_Supported_By_Iis_Integrated_Mode, "HttpRuntime.ProcessRequest"));
  7. }
  9. ProcessRequestNoDemand(wr); //调用ProcessRequestNoDemand函数
  10. }


2、ProcessRequestNoDemand函数，调用ProcessRequestNow函数

  1. internal static void ProcessRequestNoDemand(HttpWorkerRequest wr) {
  2. RequestQueue rq = _theRuntime._requestQueue;
  4. wr.UpdateInitialCounters();
  6. if (rq != null) // could be null before first request
  7. wr = rq.GetRequestToExecute(wr);
  9. if (wr != null) {
  10. CalculateWaitTimeAndUpdatePerfCounter(wr);
  11. wr.ResetStartTime();
  12. ProcessRequestNow(wr);调用ProcessRequestNow
  13. }
  14. }

3、ProcessRequestNow函数，调用ProcessRequestInternal

  1. internal static void ProcessRequestNow(HttpWorkerRequest wr)
  2. {
  3. _theRuntime.ProcessRequestInternal(wr); //调用ProcessRequestInternal
  4. }

4、ProcessRequestInternal函数，调用HttpApplicatioinFactory的GetApplicationInstance()函数来获取HttpApplication实例对象

  1. private void ProcessRequestInternal(HttpWorkerRequest wr) {
  2. // Count active requests
  3. Interlocked.Increment( ref _activeRequestCount);
  6. // Get application instance
  7. IHttpHandler app = HttpApplicationFactory.GetApplicationInstance(context); //获取HttpApplication对象
  9. if (app == null)
  10. throw new HttpException(SR.GetString(SR.Unable_create_app_object));
  12. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_START_HANDLER, context.WorkerRequest, app.GetType().FullName, "Start");
  14. if (app is IHttpAsyncHandler) {
  15. // asynchronous handler
  16. IHttpAsyncHandler asyncHandler = (IHttpAsyncHandler)app;
  17. context.AsyncAppHandler = asyncHandler;
  18. //来到了真正处理请求步骤
  19. asyncHandler.BeginProcessRequest(context, _handlerCompletionCallback, context);
  20. }
  21. else {
  22. // synchronous handler
  23. app.ProcessRequest(context);
  24. FinishRequest(context.WorkerRequest, context, null);
  25. }
  26. }
  27. catch (Exception e) {
  28. context.Response.InitResponseWriter();
  29. FinishRequest(wr, context, e);
  30. }
  31. }

说明：以上4个步骤集成模式和经典模式分不同的函数执行，从下面开始两种模式调用相同的函数，只是在函数中针对不同的模式进行不同的处理

5、进入HttpApplicationFactory，调用GetNormalApplicationInstance函数

  1. internal static IHttpHandler GetApplicationInstance(HttpContext context) {
  2. if (_customApplication != null)
  3. return _customApplication;
  5.   if (context.Request.IsDebuggingRequest)
  6. return new HttpDebugHandler();
  8. _theApplicationFactory.EnsureInited();
  10. _theApplicationFactory.EnsureAppStartCalled(context);
  12. return _theApplicationFactory.GetNormalApplicationInstance(context); //返回HttpApplication实例
  13. }

6、进入GetNormalApplicationInstance函数，调用InitInternal初始化HttpApplication内部对象

  1. private HttpApplication GetNormalApplicationInstance(HttpContext context) {
  2. HttpApplication app = null;
  4. lock (_freeList) {
  5. if (_numFreeAppInstances > 0) {
  6. app = (HttpApplication)_freeList.Pop();
  7. _numFreeAppInstances--;
  9. if (_numFreeAppInstances < _minFreeAppInstances) {
  10. _minFreeAppInstances = _numFreeAppInstances;
  11. }
  12. }
  13. }
  15. if (app == null) {
  16. // If ran out of instances, create a new one
  17. app = (HttpApplication)HttpRuntime.CreateNonPublicInstance(_theApplicationType);
  19. using ( new ApplicationImpersonationContext()) {
  20. app.InitInternal(context, _state, _eventHandlerMethods); //初始化Application内部对象
  21. }
  22. }
  24. if (AppSettings.UseTaskFriendlySynchronizationContext) {
  25. // When this HttpApplication instance is no longer in use, recycle it.
  26. app.ApplicationInstanceConsumersCounter = new CountdownTask( 1); // representing required call to HttpApplication.ReleaseAppInstance
  27. app.ApplicationInstanceConsumersCounter.Task.ContinueWith((_, o) => RecycleApplicationInstance((HttpApplication)o), app, TaskContinuationOptions.ExecuteSynchronously);
  28. }
  29. return app;
  30. }

7、进入HttpApplication,调用InitInternal函数来初始化Application内部对象。初始化HttpModule和建立处理执行步骤


  1. internal void InitInternal(HttpContext context, HttpApplicationState state, MethodInfo[] handlers) {
  2. Debug.Assert(context != null, "context != null");
  4. // Remember state
  5. _state = state;
  7. PerfCounters.IncrementCounter(AppPerfCounter.PIPELINES);
  9. try {
  10. try {
  11. // Remember context for config lookups
  12. _initContext = context;
  13. _initContext.ApplicationInstance = this;
  15. // Set config path to be application path for the application initialization
  16. context.ConfigurationPath = context.Request.ApplicationPathObject;
  18. // keep HttpContext.Current working while running user code
  19. using ( new DisposableHttpContextWrapper(context)) {
  21. // Build module list from config 根据IIS集成模式和经典模式初始化HttpMudule
  22. if (HttpRuntime.UseIntegratedPipeline) { //集成模式
  24. Debug.Assert(_moduleConfigInfo != null, "_moduleConfigInfo != null");
  25. Debug.Assert(_moduleConfigInfo.Count >= 0, "_moduleConfigInfo.Count >= 0");
  27. try {
  28. context.HideRequestResponse = true;
  29. _hideRequestResponse = true;
  30. InitIntegratedModules(); //集成模式初始化HttpModule
  31. }
  32. finally {
  33. context.HideRequestResponse = false;
  34. _hideRequestResponse = false;
  35. }
  36. }
  37. else { //经典模式
  38. InitModules(); //经典模式初始化HttpModule
  40. // this is used exclusively for integrated mode
  41. Debug.Assert( null == _moduleContainers, "null == _moduleContainers");
  42. }
  44. // Hookup event handlers via reflection
  45. if (handlers != null)
  46. HookupEventHandlersForApplicationAndModules(handlers);
  48. // Initialization of the derived class
  49. _context = context;
  50. if (HttpRuntime.UseIntegratedPipeline && _context != null) {
  51. _context.HideRequestResponse = true;
  52. }
  53. _hideRequestResponse = true;
  55. try {
  56. Init();
  57. }
  58. catch (Exception e) {
  59. RecordError(e);
  60. }
  61. }
  63. if (HttpRuntime.UseIntegratedPipeline && _context != null) {
  64. _context.HideRequestResponse = false;
  65. }
  66. _hideRequestResponse = false;
  67. _context = null;
  68. _resumeStepsWaitCallback= new WaitCallback( this.ResumeStepsWaitCallback);
  70. // Construct the execution steps array
  71. <span style= "color:#FF0000;"><strong> if (HttpRuntime.UseIntegratedPipeline) {</strong></span> //集成模式 调用PipelineStepManager
  72. <span style= "color:#FF0000;"><strong>_stepManager = new PipelineStepManager( this);</strong></span>
  73. }
  74. else {
  75. <span style= "color:#FF0000;"><strong> _stepManager = new ApplicationStepManager( this);</strong></span> //经典模式 调用 ApplicationStepManager
  76. }
  78. <span style= "color:#FF0000;"><strong>_stepManager.BuildSteps(_resumeStepsWaitCallback);</strong></span> //建立执行处理步骤
  79. }
  80. finally {
  81. _initInternalCompleted = true;
  83. // Reset config path
  84. context.ConfigurationPath = null;
  86. // don't hold on to the context
  87. _initContext.ApplicationInstance = null;
  88. _initContext = null;
  89. }
  90. }
  91. catch { // Protect against exception filters
  92. throw;
  93. }
  94. }

8、初始化HttpModule，包含系统默认的HttpModule和自定义的HttpModule

1）、系统默认的HttpModule：

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config


2）、自定义的HttpModule在网站的Web.config中配置

经典模式：

  1. <system.web>
  2. <httpModules>
  3. < add name= "mymodule" type= "WebApplication2.myModule"/>
  4. </httpModules>
  5. </system.web>
集成模式：
  1. <system.webServer>
  2. <modules>
  3. < add name= "mymodule" type= "WebApplication2.myModule"/>
  4. </modules>
  5. </system.webServer>

3）、经典模式初始化：

  1. private void InitModules() {
  3. //读取配置文件中HttpModules节点
  4.  HttpModulesSection pconfig = RuntimeConfig.GetAppConfig().HttpModules;
  6. //获取HttpModule集合
  7. HttpModuleCollection moduleCollection = pconfig.CreateModules();
  8. HttpModuleCollection dynamicModules = CreateDynamicModules();
  10. moduleCollection.AppendCollection(dynamicModules);
  11. _moduleCollection = moduleCollection; // don't assign until all ops have succeeded
  13. InitModulesCommon(); //调用InitModulesCommon
  14. }

4）、初始化各个HttpModule对象.

  1. private void InitModulesCommon() {
  2. int n = _moduleCollection.Count;
  4. for ( int i = 0; i < n; i++) {
  5. // remember the module being inited for event subscriptions
  6. // we'll later use this for routing
  7. _currentModuleCollectionKey = _moduleCollection.GetKey(i);
  8. _moduleCollection[i].Init( this); //初始化每个HttpModule
  9. }
  11. _currentModuleCollectionKey = null;
  12. InitAppLevelCulture();
  13. }

5）、初始化HttpModule，在Init函数中注册HttpApplication对象的事件，这里举了两个例子

OutputCacheModule.cs  web.config中默认第一个HttpModule

  1. void IHttpModule.Init(HttpApplication app) {
  2. OutputCacheSection cacheConfig = RuntimeConfig.GetAppConfig().OutputCache;
  3. if (cacheConfig.EnableOutputCache) {
  4. app.ResolveRequestCache += new EventHandler( this.OnEnter);
  5. app.UpdateRequestCache += new EventHandler( this.OnLeave);
  6. }
  7. }

SessionStateModule.cs web.config中默认第二个HttpModule，实现Session的系统HttpModule

  1. public void Init(HttpApplication app) {
  2. bool initModuleCalled = false;
  3. SessionStateSection config = RuntimeConfig.GetAppConfig().SessionState;
  5. if (!s_oneTimeInit) {
  6. s_lock.AcquireWriterLock();
  7. try {
  8. if (!s_oneTimeInit) {
  9. InitModuleFromConfig(app, config);
  10. initModuleCalled = true;
  12. if (!CheckTrustLevel(config))
  13. s_trustLevelInsufficient = true;
  15. s_timeout = ( int)config.Timeout.TotalMinutes;
  17. s_useHostingIdentity = config.UseHostingIdentity;
  19. // See if we can try InProc optimization. See inline doc of s_allowInProcOptimization
  20. // for details.
  21. if (config.Mode == SessionStateMode.InProc &&
  22. _usingAspnetSessionIdManager) {
  23. s_allowInProcOptimization = true;
  24. }
  26. if (config.Mode != SessionStateMode.Custom &&
  27. config.Mode != SessionStateMode.Off &&
  28. !config.RegenerateExpiredSessionId) {
  29. s_allowDelayedStateStoreItemCreation = true;
  30. }
  32. s_configExecutionTimeout = RuntimeConfig.GetConfig().HttpRuntime.ExecutionTimeout;
  34. s_configRegenerateExpiredSessionId = config.RegenerateExpiredSessionId;
  35. s_configCookieless = config.Cookieless;
  36. s_configMode = config.Mode;
  38. // The last thing to set in this if-block.
  39. s_oneTimeInit = true;
  41. Debug.Trace( "SessionStateModuleInit",
  42. "Configuration: _mode=" + config.Mode +
  43. ";Timeout=" + config.Timeout +
  44. ";CookieMode=" + config.Cookieless +
  45. ";SqlConnectionString=" + config.SqlConnectionString +
  46. ";StateConnectionString=" + config.StateConnectionString +
  47. ";s_allowInProcOptimization=" + s_allowInProcOptimization +
  48. ";s_allowDelayedStateStoreItemCreation=" + s_allowDelayedStateStoreItemCreation);
  50. }
  51. }
  52. finally {
  53. s_lock.ReleaseWriterLock();
  54. }
  55. }
  57. if (!initModuleCalled) {
  58. InitModuleFromConfig(app, config);
  59. }
  61. if (s_trustLevelInsufficient) {
  62. throw new HttpException(SR.GetString(SR.Session_state_need_higher_trust));
  63. }
  64. }

集成模式初始化HttpModule代码我就不贴出来了，大家可以在源码中查看

9、建立处理步骤BuildSteps，将所有要执行的步骤载入到一个IExecutionStep[]集合中，待后面ResumeSteps调用

经典模式：调用ApplicationStepManager类中的BuildSteps函数

  1. internal class ApplicationStepManager : StepManager {
  2. private IExecutionStep[] _execSteps;
  3. private WaitCallback _resumeStepsWaitCallback;
  4. private int _currentStepIndex;
  5. private int _numStepCalls;
  6. private int _numSyncStepCalls;
  7. private int _endRequestStepIndex;
  9. internal ApplicationStepManager(HttpApplication app): base(app) {
  10. }
  12. internal override void BuildSteps(WaitCallback stepCallback )
  13. {
  14. ArrayList steps = new ArrayList();
  15. HttpApplication app = _application;
  17. bool urlMappingsEnabled = false;
  18. UrlMappingsSection urlMappings = RuntimeConfig.GetConfig().UrlMappings;
  19. urlMappingsEnabled = urlMappings.IsEnabled && ( urlMappings.UrlMappings.Count > 0 );
  21. steps.Add( new ValidateRequestExecutionStep(app));
  22. steps.Add( new ValidatePathExecutionStep(app));
  24. if (urlMappingsEnabled)
  25. steps.Add( new UrlMappingsExecutionStep(app)); // url mappings
  27. app.CreateEventExecutionSteps(HttpApplication.EventBeginRequest, steps);
  28. app.CreateEventExecutionSteps(HttpApplication.EventAuthenticateRequest, steps);
  29. app.CreateEventExecutionSteps(HttpApplication.EventDefaultAuthentication, steps);
  30. app.CreateEventExecutionSteps(HttpApplication.EventPostAuthenticateRequest, steps);
  31. app.CreateEventExecutionSteps(HttpApplication.EventAuthorizeRequest, steps);
  32. app.CreateEventExecutionSteps(HttpApplication.EventPostAuthorizeRequest, steps);
  33. app.CreateEventExecutionSteps(HttpApplication.EventResolveRequestCache, steps);
  34. app.CreateEventExecutionSteps(HttpApplication.EventPostResolveRequestCache, steps);
  35. steps.Add( new MapHandlerExecutionStep(app)); //分配一个Handler
  36. app.CreateEventExecutionSteps(HttpApplication.EventPostMapRequestHandler, steps);
  37. app.CreateEventExecutionSteps(HttpApplication.EventAcquireRequestState, steps);
  38. app.CreateEventExecutionSteps(HttpApplication.EventPostAcquireRequestState, steps);
  39. app.CreateEventExecutionSteps(HttpApplication.EventPreRequestHandlerExecute, steps);
  40. steps.Add(app.CreateImplicitAsyncPreloadExecutionStep()); // implict async preload step
  41. steps.Add( new CallHandlerExecutionStep(app)); // 执行HttpHandler
  42. app.CreateEventExecutionSteps(HttpApplication.EventPostRequestHandlerExecute, steps);
  43. app.CreateEventExecutionSteps(HttpApplication.EventReleaseRequestState, steps);
  44. app.CreateEventExecutionSteps(HttpApplication.EventPostReleaseRequestState, steps);
  45. steps.Add( new CallFilterExecutionStep(app)); // filtering
  46. app.CreateEventExecutionSteps(HttpApplication.EventUpdateRequestCache, steps);
  47. app.CreateEventExecutionSteps(HttpApplication.EventPostUpdateRequestCache, steps);
  48. _endRequestStepIndex = steps.Count;
  49. app.CreateEventExecutionSteps(HttpApplication.EventEndRequest, steps);
  50. steps.Add( new NoopExecutionStep()); // the last is always there
  52. _execSteps = new IExecutionStep[steps.Count];
  53. steps.CopyTo(_execSteps);
  55. // callback for async completion when reposting to threadpool thread
  56. _resumeStepsWaitCallback = stepCallback;
  57. }

集成模式：调用PipelineStepManager类中的 BuildSteps函数

  1. internal override void BuildSteps(WaitCallback stepCallback) {
  2. Debug.Trace( "PipelineRuntime", "BuildSteps");
  3. //ArrayList steps = new ArrayList();
  4. HttpApplication app = _application;
  6. // add special steps that don't currently
  7. // correspond to a configured handler
  9. IExecutionStep materializeStep = new MaterializeHandlerExecutionStep(app);
  11. // implicit map step
  12. app.AddEventMapping(
  13. HttpApplication.IMPLICIT_HANDLER,
  14. RequestNotification.MapRequestHandler,
  15. false, materializeStep);
  17. // implicit async preload step
  18. app.AddEventMapping(
  19. HttpApplication.IMPLICIT_HANDLER,
  20. RequestNotification.ExecuteRequestHandler,
  21. false, app.CreateImplicitAsyncPreloadExecutionStep());
  23. // implicit handler routing step
  24. IExecutionStep handlerStep = new CallHandlerExecutionStep(app);
  26. app.AddEventMapping(
  27. HttpApplication.IMPLICIT_HANDLER,
  28. RequestNotification.ExecuteRequestHandler,
  29. false, handlerStep);
  31. // implicit handler WebSockets step
  32. IExecutionStep webSocketsStep = new TransitionToWebSocketsExecutionStep(app);
  34. app.AddEventMapping(
  35. HttpApplication.IMPLICIT_HANDLER,
  36. RequestNotification.EndRequest,
  37. true /* isPostNotification */, webSocketsStep);
  39. // add implicit request filtering step
  40. IExecutionStep filterStep = new CallFilterExecutionStep(app);
  42. // normally, this executes during UpdateRequestCache as a high priority module
  43. app.AddEventMapping(
  44. HttpApplication.IMPLICIT_FILTER_MODULE,
  45. RequestNotification.UpdateRequestCache,
  46. false, filterStep);
  48. // for error conditions, this executes during LogRequest as a high priority module
  49. app.AddEventMapping(
  50. HttpApplication.IMPLICIT_FILTER_MODULE,
  51. RequestNotification.LogRequest,
  52. false, filterStep);
  54. _resumeStepsWaitCallback = stepCallback;
  55. }


10、真正处理请求阶段， 调用ResumeSteps函数来执行处理步骤

经典模式：

返回到ProcessRequestInternal函数中执行BeginProcessRequest函数

  1. IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, Object extraData) {
  2. HttpAsyncResult result;
  4. // Setup the asynchronous stuff and application variables
  5. _context = context;
  6. _context.ApplicationInstance = this;
  8. _stepManager.InitRequest();
  10. // Make sure the context stays rooted (including all async operations)
  11. _context.Root();
  13. // Create the async result
  14. result = new HttpAsyncResult(cb, extraData);
  16. // Remember the async result for use in async completions
  17. AsyncResult = result;
  19. if (_context.TraceIsEnabled)
  20. HttpRuntime.Profile.StartRequest(_context);
  22. // Start the application
  23. ResumeSteps( null); //执行处理步骤
  25. // Return the async result
  26. return result;
  27. }

ResumeSteps函数，调用ExecuteStepl函数来执行处理步骤

  1. internal override void ResumeSteps(Exception error) {
  2. bool appCompleted = false;
  3. bool stepCompletedSynchronously = true;
  4. HttpApplication app = _application;
  5. CountdownTask appInstanceConsumersCounter = app.ApplicationInstanceConsumersCounter;
  6. HttpContext context = app.Context;
  7. ThreadContext threadContext = null;
  8. AspNetSynchronizationContextBase syncContext = context.SyncContext;
  10. Debug.Trace( "Async", "HttpApplication.ResumeSteps");
  12. try {
  13. if (appInstanceConsumersCounter != null) {
  14. appInstanceConsumersCounter.MarkOperationPending(); // ResumeSteps call started
  15. }
  17. using (syncContext.AcquireThreadLock()) {
  19. //执行步骤
  20. error = app.ExecuteStep(_execSteps[_currentStepIndex], ref stepCompletedSynchronously);
  22. }
  23. }

集成模式：

返回到ProcessRequestNotificationPrivate函数，执行BeginProcessRequestNotification

BeginProcessRequestNotification函数，调用ResumeSteps执行处理步骤

  1. internal IAsyncResult BeginProcessRequestNotification(HttpContext context, AsyncCallback cb)
  2. {
  3. if ( this._context == null)
  4. {
  5. this.AssignContext(context);
  6. }
  7. context.CurrentModuleEventIndex = -1;
  8. HttpAsyncResult result = new HttpAsyncResult(cb, context);
  9. context.NotificationContext.AsyncResult = result;
  10. this.ResumeSteps( null); //开始执行处理步骤
  11. return result;
  12. }


 ResumeSteps

  1. // PipelineStepManager::ResumeSteps
  2. // called from IIS7 (on IIS thread) via BeginProcessRequestNotification
  3. // or from an async completion (on CLR thread) via HttpApplication::ResumeStepsFromThreadPoolThread
  4. // This attribute prevents undesirable 'just-my-code' debugging behavior (VSWhidbey 404406/VSWhidbey 609188)
  5. [ System.Diagnostics.DebuggerStepperBoundaryAttribute]
  6. internal override void ResumeSteps(Exception error) {
  7. HttpContext context = _application.Context;
  8. IIS7WorkerRequest wr = context.WorkerRequest as IIS7WorkerRequest;
  9. AspNetSynchronizationContextBase syncContext = context.SyncContext;
  11. RequestNotificationStatus status = RequestNotificationStatus.Continue;
  12. ThreadContext threadContext = null;
  13. bool needToDisassociateThreadContext = false;
  14. bool isSynchronousCompletion = false;
  15. bool needToComplete = false;
  16. bool stepCompletedSynchronously = false;
  17. int currentModuleLastEventIndex = _application.CurrentModuleContainer.GetEventCount(context.CurrentNotification, context.IsPostNotification) - 1;
  18. CountdownTask appInstanceConsumersCounter = _application.ApplicationInstanceConsumersCounter;
  20. using (context.RootedObjects.WithinTraceBlock()) {
  22. error = _application.ExecuteStep(step, ref stepCompletedSynchronously); //执行处理步骤
  24. }
  25. }

11、ExecuteStep执行BuildSteps中的各个步骤

  1. internal Exception ExecuteStep(IExecutionStep step, ref bool completedSynchronously) {
  2. Exception error = null;
  4. try {
  5. try {
  6. if (step.IsCancellable) {
  7. _context.BeginCancellablePeriod(); // request can be cancelled from this point
  9. try {
  10. step.Execute();
  11. }
  12. finally {
  13. _context.EndCancellablePeriod(); // request can be cancelled until this point
  14. }
  16. _context.WaitForExceptionIfCancelled(); // wait outside of finally
  17. }
  18. else {
  19. step.Execute();</strong></span>
  20. }
  22. if (!step.CompletedSynchronously) {
  23. completedSynchronously = false;
  24. return null;
  25. }
  26. }
  29. }


这里贴出了两个很重要的步骤：获取HttpHandler（MaterializeHandlerExecutionStep）和执行HttpHandler（CallHandlerExecutionStep）

经典模式：

MapHandlerExecutionStep

  1. // execution step -- map HTTP handler (used to be a separate module)
  2. internal class < span style= "color:#FF0000;"><strong>MapHandlerExecutionStep </strong></span>: IExecutionStep {
  3. private HttpApplication _application;
  5. internal MapHandlerExecutionStep(HttpApplication app) {
  6. _application = app;
  7. }
  9. void IExecutionStep.Execute() {
  10. HttpContext context = _application.Context;
  11. HttpRequest request = context.Request;
  13. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_ENTER, context.WorkerRequest);
  14. //获取HttpHandler
  15. context.Handler = _application.MapHttpHandler(
  16. context,
  17. request.RequestType,
  18. request.FilePathObject,
  19. request.PhysicalPathInternal,
  20. false /*useAppConfig*/);</strong></span>
  21. Debug.Assert(context.ConfigurationPath == context.Request.FilePathObject, "context.ConfigurationPath (" +
  22. context.ConfigurationPath + ") != context.Request.FilePath (" + context.Request.FilePath + ")");
  24. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_LEAVE, context.WorkerRequest);
  25. }
  27. bool IExecutionStep.CompletedSynchronously {
  28. get { return true;}
  29. }
  31. bool IExecutionStep.IsCancellable {
  32. get { return false; }
  33. }
  34. }

MapHttpHandler获取处理请求的HttpHandler

  1. internal IHttpHandler MapHttpHandler(HttpContext context, string requestType, VirtualPath path, string pathTranslated, bool useAppConfig)
  2. {
  3. IHttpHandler handler = (context.ServerExecuteDepth == 0) ? context.RemapHandlerInstance : null;
  4. using ( new ApplicationImpersonationContext())
  5. {
  6. if (handler != null)
  7. {
  8. return handler;
  9. }
  10. HttpHandlerAction mapping = this.GetHandlerMapping(context, requestType, path, useAppConfig);
  11. if (mapping == null)
  12. {
  13. PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_NOT_FOUND);
  14. PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_FAILED);
  15. throw new HttpException(SR.GetString( "Http_handler_not_found_for_request_type", new object[] { requestType }));
  16. }
  17. IHttpHandlerFactory factory = this.GetFactory(mapping); //获取HttpHandlerFactory对象，如果网站Web.config中自定义了HttpHandlerFactory对象，则会覆盖系统默认的
  18. try
  19. {
  20. IHttpHandlerFactory2 factory2 = factory as IHttpHandlerFactory2;
  21. if (factory2 != null)
  22. {
  23. handler = factory2.GetHandler(context, requestType, path, pathTranslated); //获取HttpHandler对象，如果为自定义的HttpHandlerFactory，则返回自定义HttpHandlerFactory中设置的HttpHandler
  24. }
  25. else
  26. {
  27. handler = factory.GetHandler(context, requestType, path.VirtualPathString, pathTranslated);
  28. }
  29. }
  30. catch (FileNotFoundException exception)
  31. {
  32. if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
  33. {
  34. throw new HttpException( 0x194, null, exception);
  35. }
  36. throw new HttpException( 0x194, null);
  37. }
  38. catch (DirectoryNotFoundException exception2)
  39. {
  40. if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
  41. {
  42. throw new HttpException( 0x194, null, exception2);
  43. }
  44. throw new HttpException( 0x194, null);
  45. }
  46. catch (PathTooLongException exception3)
  47. {
  48. if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
  49. {
  50. throw new HttpException( 0x19e, null, exception3);
  51. }
  52. throw new HttpException( 0x19e, null);
  53. }
  54. if ( this._handlerRecycleList == null)
  55. {
  56. this._handlerRecycleList = new ArrayList();
  57. }
  58. this._handlerRecycleList.Add( new HandlerWithFactory(handler, factory));
  59. }
  60. return handler;
  61. }


集成模式：

MaterializeHandlerExecutionStep步骤

  1. internal class MaterializeHandlerExecutionStep: IExecutionStep {
  2. private HttpApplication _application;
  4. internal MaterializeHandlerExecutionStep(HttpApplication app) {
  5. _application = app;
  6. }
  8. void IExecutionStep.Execute() {
  9. HttpContext context = _application.Context;
  10. HttpRequest request = context.Request;
  11. IHttpHandler handler = null;
  12. string configType = null;
  14. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_ENTER, context.WorkerRequest);
  16. IIS7WorkerRequest wr = context.WorkerRequest as IIS7WorkerRequest;
  18. // Get handler
  19. if (context.RemapHandlerInstance != null){
  20. //RemapHandler overrides all
  21. wr.SetScriptMapForRemapHandler();
  22. context.Handler = context.RemapHandlerInstance;
  23. }
  24. else if (request.RewrittenUrl != null) {
  25. // RewritePath, we need to re-map the handler
  26. bool handlerExists;
  27. configType = wr.ReMapHandlerAndGetHandlerTypeString(context, request.Path, out handlerExists);
  28. if (!handlerExists) {
  29. // WOS 1973590: When RewritePath is used with missing handler in Integrated Mode,an empty response 200 is returned instead of 404
  30. throw new HttpException( 404, SR.GetString(SR.Http_handler_not_found_for_request_type, request.RequestType));
  31. }
  32. }
  33. else {
  34. configType = wr.GetManagedHandlerType();
  35. }
  37. if (!String.IsNullOrEmpty(configType)) {
  38. IHttpHandlerFactory factory = _application.GetFactory(configType); //获取HttpHandlerFactory对象
  39. string pathTranslated = request.PhysicalPathInternal;
  41. try {
  42. handler = factory.GetHandler(context, request.RequestType, request.FilePath, pathTranslated); //获取HttpHandler对象
  43. }
  44. catch (FileNotFoundException e) {
  45. if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
  46. throw new HttpException( 404, null, e);
  47. else
  48. throw new HttpException( 404, null);
  49. }
  50. catch (DirectoryNotFoundException e) {
  51. if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
  52. throw new HttpException( 404, null, e);
  53. else
  54. throw new HttpException( 404, null);
  55. }
  56. catch (PathTooLongException e) {
  57. if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
  58. throw new HttpException( 414, null, e);
  59. else
  60. throw new HttpException( 414, null);
  61. }
  63. context.Handler = handler;
  65. // Remember for recycling
  66. if (_application._handlerRecycleList == null)
  67. _application._handlerRecycleList = new ArrayList();
  68. _application._handlerRecycleList.Add( new HandlerWithFactory(handler, factory));
  69. }
  71. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_LEAVE, context.WorkerRequest);
  72. }
  74. bool IExecutionStep.CompletedSynchronously {
  75. get { return true;}
  76. }
  78. bool IExecutionStep.IsCancellable {
  79. get { return false; }
  80. }
  81. }

12、执行callhandlerexecutestep步骤，调用handler.ProcessRequest(context)，如果HttpHandler类型为Page，则开始Page页生命周期

  1. internal class CallHandlerExecutionStep: IExecutionStep {
  2. private HttpApplication _application;
  3. private AsyncCallback _completionCallback;
  4. private IHttpAsyncHandler _handler; // per call
  5. private AsyncStepCompletionInfo _asyncStepCompletionInfo; // per call
  6. private bool _sync; // per call
  8. internal CallHandlerExecutionStep(HttpApplication app) {
  9. _application = app;
  10. _completionCallback = new AsyncCallback( this.OnAsyncHandlerCompletion);
  11. }
  13. voidIExecutionStep.Execute()
  14. {
  15. HttpContext context = _application.Context;
  16. IHttpHandler handler = context.Handler;
  18. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_ENTER, context.WorkerRequest);
  20. if (handler != null && HttpRuntime.UseIntegratedPipeline) {
  21. IIS7WorkerRequest wr = context.WorkerRequest as IIS7WorkerRequest;
  22. if (wr != null && wr.IsHandlerExecutionDenied()) {
  23. _sync = true;
  24. HttpException error = new HttpException( 403, SR.GetString(SR.Handler_access_denied));
  25. error.SetFormatter( new PageForbiddenErrorFormatter(context.Request.Path, SR.GetString(SR.Handler_access_denied)));
  26. throw error;
  27. }
  28. }
  30. if (handler == null) {
  31. _sync = true;
  32. }
  33. else if (handler is IHttpAsyncHandler) {
  34. // asynchronous handler
  35. IHttpAsyncHandler asyncHandler = (IHttpAsyncHandler)handler;
  37. _sync = false;
  38. _handler = asyncHandler;
  40. var beginProcessRequestDelegate = AppVerifier.WrapBeginMethod<HttpContext>(_application, asyncHandler.BeginProcessRequest);
  42. _asyncStepCompletionInfo.Reset();
  43. context.SyncContext.AllowVoidAsyncOperations();
  44. IAsyncResult ar;
  45. try {
  46. ar = beginProcessRequestDelegate(context, _completionCallback, null);
  47. }
  48. catch {
  49. // The asynchronous step has completed, so we should disallow further
  50. // async operations until the next step.
  51. context.SyncContext.ProhibitVoidAsyncOperations();
  52. throw;
  53. }
  55. bool operationCompleted;
  56. bool mustCallEndHandler;
  57. _asyncStepCompletionInfo.RegisterBeginUnwound(ar, out operationCompleted, out mustCallEndHandler);
  59. if (operationCompleted) {
  60. _sync = true;
  61. _handler = null; // not to remember
  63. // The asynchronous step has completed, so we should disallow further
  64. // async operations until the next step.
  65. context.SyncContext.ProhibitVoidAsyncOperations();
  67. try {
  68. if (mustCallEndHandler) {
  69. asyncHandler.EndProcessRequest(ar);
  70. }
  72. _asyncStepCompletionInfo.ReportError();
  73. }
  74. finally {
  75. SuppressPostEndRequestIfNecessary(context);
  77. // In Integrated mode, generate the necessary response headers
  78. // after the ASP.NET handler runs
  79. context.Response.GenerateResponseHeadersForHandler();
  80. }
  82. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);
  83. }
  84. }
  85. else {
  86. //同步 handler
  87. _sync = true;
  89. context.SyncContext.SetSyncCaller();
  91. try {
  92. handler.ProcessRequest(context); //开始Page页面生命周期
  93. }
  94. finally {
  95. context.SyncContext.ResetSyncCaller();
  96. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);
  98. SuppressPostEndRequestIfNecessary(context);
  100. context.Response.GenerateResponseHeadersForHandler();
  101. }
  102. }
  103. }
  105. bool IExecutionStep.CompletedSynchronously {
  106. get { return _sync;}
  107. }
  109. bool IExecutionStep.IsCancellable {
  110. // launching of async handler should not be cancellable
  111. get { return (_application.Context.Handler is IHttpAsyncHandler) ? false : true; }
  112. }
  113. }

13、进入Page类的 ProcessRequest方法开始处理请求


  1. private void ProcessRequest() {
  2. // culture needs to be saved/restored only on synchronous pages (if at all)
  3. // save culture
  4. Thread currentThread = Thread.CurrentThread;
  5. CultureInfo prevCulture = currentThread.CurrentCulture;
  6. CultureInfo prevUICulture = currentThread.CurrentUICulture;
  8. try {
  9. ProcessRequest( true /*includeStagesBeforeAsyncPoint*/, true /*includeStagesAfterAsyncPoint*/); //调用ProcessRequest函数
  10. }
  11. finally {
  12. // restore culture
  13. RestoreCultures(currentThread, prevCulture, prevUICulture);
  14. }
  15. }

14、进入ProcessRequest,调用ProcessRequestMain函数


  1. private void ProcessRequest(bool includeStagesBeforeAsyncPoint, bool includeStagesAfterAsyncPoint) {
  2. // Initialize the object and build the tree of controls.
  3. // This must happen *after* the intrinsics have been set.
  4. // On async pages only call Initialize once (ProcessRequest is called twice)
  5. if (includeStagesBeforeAsyncPoint) {
  6. FrameworkInitialize();
  8. this.ControlState = ControlState.FrameworkInitialized;
  9. }
  11. bool needToCallEndTrace = Context.WorkerRequest is IIS7WorkerRequest;
  12. try {
  13. try {
  14. if (IsTransacted) {
  15. ProcessRequestTransacted();
  16. }
  17. else {
  18. // No transactions
  19. ProcessRequestMain(includeStagesBeforeAsyncPoint, includeStagesAfterAsyncPoint); //调用ProcessRequestMain函数
  20. }
  22. if (includeStagesAfterAsyncPoint) {
  23. needToCallEndTrace = false;
  24. ProcessRequestEndTrace();
  25. }
  26. }
  27. catch (ThreadAbortException) {
  28. try {
  29. if (needToCallEndTrace)
  30. ProcessRequestEndTrace();
  31. } catch {}
  32. }
  33. finally {
  34. if (includeStagesAfterAsyncPoint) {
  35. ProcessRequestCleanup();
  36. }
  37. }
  38. }
  39. catch { throw; } // Prevent Exception Filter Security Issue (ASURT 122835)
  40. }

15、进入ProcessRequestMain,开始Page页面主体处理过程

  1. private void ProcessRequestMain(bool includeStagesBeforeAsyncPoint, bool includeStagesAfterAsyncPoint) {
  2. try {
  3. HttpContext con = Context;
  5. string exportedWebPartID = null;
  7. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin PreInit");
  8. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_ENTER, _context.WorkerRequest);
  9. PerformPreInit(); //Page页面生命周期的OnPerLoad阶段
  10. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_LEAVE, _context.WorkerRequest);
  11. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End PreInit");
  13. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin Init");
  14. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_ENTER, _context.WorkerRequest);
  15. InitRecursive( null);
  16. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_LEAVE, _context.WorkerRequest);
  17. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End Init");
  19. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin InitComplete");
  20. OnInitComplete(EventArgs.Empty); //Page页面生命周期的OnInitComplete阶段
  21. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End InitComplete");
  23. if (IsPostBack) {
  24. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin LoadState");
  25. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_ENTER, _context.WorkerRequest);
  26. LoadAllState(); //Page页面生命周期的LoadViewState阶段（加载视图状态）
  27. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_LEAVE, _context.WorkerRequest);
  28. if (con.TraceIsEnabled) {
  29. Trace.Write( "aspx.page", "End LoadState");
  30. Trace.Write( "aspx.page", "Begin ProcessPostData");
  31. }
  33. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_ENTER, _context.WorkerRequest);
  34. ProcessPostData(_requestValueCollection, true /* fBeforeLoad */); //Page页面生命周期ProcessPostData阶段（处理回发数据）
  35. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_LEAVE, _context.WorkerRequest);
  36. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End ProcessPostData");
  37. }
  39. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin PreLoad");
  40. OnPreLoad(EventArgs.Empty); //Page页面生命周期OnPreLoad阶段（预加载）
  41. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End PreLoad");
  43. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin Load");
  44. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_ENTER, _context.WorkerRequest);
  45. LoadRecursive(); //Page页面生命周期Load阶段（加载）
  46. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_LEAVE, _context.WorkerRequest);
  47. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End Load");
  49. if (IsPostBack) {
  50. // Try process the post data again (ASURT 29045)
  51. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin ProcessPostData Second Try");
  52. <span style= "color:#FF0000;"><strong> ProcessPostData(_leftoverPostData, false /* !fBeforeLoad */); //Page页面生命周期 ProcessPostData阶段</strong></span>
  53. if (con.TraceIsEnabled) {
  54. Trace.Write( "aspx.page", "End ProcessPostData Second Try");
  55. Trace.Write( "aspx.page", "Begin Raise ChangedEvents");
  56. }
  58. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_ENTER, _context.WorkerRequest);
  59. RaiseChangedEvents(); //Page页面生命周期 RaiseChangedEvents阶段（处理回发更改事件）
  60. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_LEAVE, _context.WorkerRequest);
  61. if (con.TraceIsEnabled) {
  62. Trace.Write( "aspx.page", "End Raise ChangedEvents");
  63. Trace.Write( "aspx.page", "Begin Raise PostBackEvent");
  64. }
  65. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_ENTER, _context.WorkerRequest);
  66. RaisePostBackEvent(_requestValueCollection); //Page页面生命周期 RaisePostBackEvent阶段（处理回发事件）
  67. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_LEAVE, _context.WorkerRequest);
  68. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End Raise PostBackEvent");
  69. }
  71. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin LoadComplete");
  72. OnLoadComplete(EventArgs.Empty); //Page页面生命周期 加载完成
  73. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End LoadComplete");
  75. if (IsPostBack && IsCallback) {
  76. PrepareCallback(callbackControlId); //Page页面生命周期 PrepareRender(预呈现)
  77. }
  78. else if (!IsCrossPagePostBack) {
  79. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin PreRender");
  80. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_ENTER, _context.WorkerRequest);
  81. PreRenderRecursiveInternal();
  82. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_LEAVE, _context.WorkerRequest);
  83. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End PreRender");
  84. }
  85. }
  87. /// Async Point here
  89. if (_legacyAsyncInfo == null || _legacyAsyncInfo.CallerIsBlocking) {
  90. // for non-async pages with registered async tasks - run the tasks here
  91. // also when running async page via server.execute - run the tasks here
  92. ExecuteRegisteredAsyncTasks();
  93. }
  95. // Make sure RawUrl gets validated.
  96. ValidateRawUrlIfRequired();
  98. if (includeStagesAfterAsyncPoint) {
  99. if (IsCallback) {
  100. RenderCallback();
  101. return;
  102. }
  104. if (IsCrossPagePostBack) {
  105. return;
  106. }
  108. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "Begin PreRenderComplete");
  109. PerformPreRenderComplete();
  110. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End PreRenderComplete");
  112. if (con.TraceIsEnabled) {
  113. BuildPageProfileTree(EnableViewState);
  114. Trace.Write( "aspx.page", "Begin SaveState");
  115. }
  117. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_ENTER, _context.WorkerRequest);
  119. SaveAllState(); //Page页面生命周期 SaveAllState阶段（保存视图状态）
  121. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_LEAVE, _context.WorkerRequest);
  122. if (con.TraceIsEnabled) {
  123. Trace.Write( "aspx.page", "End SaveState");
  124. Trace.Write( "aspx.page", "Begin SaveStateComplete");
  125. }
  126. OnSaveStateComplete(EventArgs.Empty);
  127. if (con.TraceIsEnabled) {
  128. Trace.Write( "aspx.page", "End SaveStateComplete");
  129. Trace.Write( "aspx.page", "Begin Render");
  130. }
  132. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_ENTER, _context.WorkerRequest);
  133. // Special-case Web Part Export so it executes in the same security context as the page itself (VSWhidbey 426574)
  134. if (exportedWebPartID != null) {
  135. ExportWebPart(exportedWebPartID);
  136. }
  137. else {
  138. RenderControl(CreateHtmlTextWriter(Response.Output)); //Page页面生命周期 Render阶段（呈现）
  139. }
  141. if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_LEAVE, _context.WorkerRequest);
  143. if (con.TraceIsEnabled) Trace.Write( "aspx.page", "End Render");
  145. CheckRemainingAsyncTasks( false);
  146. }
  148. }


至此，整个IIS处理Asp.Net完整请求就结束了，列举了各个关键处理阶段的处理函数。当我们了解.net framework内部处理机制后能够使我们理解Asp.Net运行机制和本质，对开发人员来说这很重要，不能只停留在会用会写的阶段，而且要知道其内部原理。这样不仅可以帮助我们编写更高效的代码,同时可以学习并借鉴微软的面向对象的编程思想，受益颇多！

殘遛
关注
专栏目录
IIS配置详解
08-18
IIS配置详解WORD 文档，根据IIS 来配置对应的资源站点
asp.net运行原理 详解
10-28
当我们通过浏览器向ASP.NET 2.0网站的一个asp.net页面发起请求时，在服务器端首先是IIS收到请求，IIS一看是asp.net页面，心里很开心，因为这个请求不用它处理，交给ASP.NET ISAPI就行了
IIS架构介绍
weixin_33709590的博客
09-29 339
IIS7及以上版本提供的请求-处理架构包括以下内容： Windows Process Activation Service(WAS)可以让站点支持更多协议，不仅仅是HTTP和HTTPS 可以通过增加或移除模块来自定义Web服务器引擎 集成IIS和ASP.NET请求-处理管线 本文介绍组件、模块和请求-处理架构，包括以下几个部分： IIS中的组件 协议监听器 超文本传输协议...
iis运行原理 Asp.Net详解IIS内部运行原理
sinolover的专栏
02-22 554
本章节主要讲IIS和 管道内部如何处理客户端Http请求，会较多的以代码的形式讲述，让大家对HttpApplication、HttpHandler、HttpApplicationFactory、Page这几个在处理请求过程中扮演重要角色的对象有更深入的了解。 下面我们通过单步调式跟踪System.Web.Dll源码来分析各个过程中关键处理函数 （说明：部分代码只保留了关键代码） 1、首先进入...
IIS 详解
Justin的专栏
12-16 1817
关于IIS 6.0的故事一言难尽，如果你已经在IIS技术上有所投资，IIS 6.0无疑是一个动人的、非听不可的话题。鉴于IIS 6.0和以前版本的差别实在太大了，只用一篇文章很难做到面面俱到，所以本文首先探讨IIS 6.0的安装、体系结构以及由于体系结构方面的差异带 来的全新服务功能，下一篇文章接着介绍IIS 6.0的新特性——其中有些你可能还没有听说过，另外还有默认配置方面的一些重要变化，这些变
ASP.NET 2.0运行原理及其过程简要分析
09-09
### ASP.NET 2.0运行原理及其过程简要分析 #### 概述 ASP.NET 2.0是Microsoft推出的一款用于构建动态Web应用程序的技术框架，它基于.NET Framework 2.0，提供了丰富的类库和工具集，使得Web开发更加高效、便捷。...
运行asp.net程序 报错：磁盘空间不足
12-15
您可能感兴趣的文章:.NET调用控制台下生成的exe文件,传参及获取返回参数的思路及代码.NET实现:将EXE设置开机自动启动asp.net运行原理 详解ASP.NET也像WinForm程序一样运行的实现方法Asp.net在IIS上运行不了的解决...
IIS的工作原理详解W3SVC
03-15
DirectoryEntry是.Net给我们的一大礼物，他的名字我们就知道他的功能--目录入口。使用过ADSI的人都知道操作IIS，WinNT这些时，我们还需要提供他们的Path，操作IIS时，这个Path的格式为： IIS://ComputerName/Service/Website/Directory ComputerName：即操作的服务器的名字，可以是名字也可以是IP，经常用的就是localhost Service：即操作的服务器，IIS中有Web，也有FTP，还有SMTP这些服务，我们主要是操作IIS的Web功能，因此此处就是"W3SVC",如果是FTP则应是"MSFTPSVC"
winIIS使用详解
11-07
WIN2000服务器安全配置,Win2000 Server入侵监测, IIS使用详解,IIS服务器完全配置图解教程,IIS服务器组建攻略,服务器终极安全设置与优化指南
web服务器--iis（讲解）
WTO98的博客
12-11 7172
一.什么是iis iis是Internet Information Services的缩写，意为互联网信息服务，是由微软公司提供的基于运行Microsoft Windows的互联网基本服务。最初是Windows NT版本的可选包，随后内置在Windows 2000、Windows XP Professional和Windows Server 2003一起发行，但在Windows XP ...
IIS安装、发布、使用详解
Sam_Siemens的专栏
09-27 2997
IIS 运行环境： 硬件：最低配置：486/50以上，16M内存，50M硬盘空间建议配置：P90，32-64M内存，200M硬盘空间软件：NT Server 4.0， Service Pack 3，IE浏览器（4.0以上版本），支持 TCP/IP协议或者：Windows 2
IIS6.0功能及应用的文章
BigIcicle的专栏
01-04 906
【摘 要】本文全面详细介绍IIS6.0功能及应用的文章专题，让你彻底掌握这一技术。 　　关于IIS 6.0的故事一言难尽，如果你已经在IIS技术上有所投资，IIS 6.0无疑是一个动人的、非听不可的话题。鉴于IIS 6.0和以前版本的差别实在太大了，只用一篇文章很难做到面面俱到，所以本文首先探讨IIS 6.0的安装、体系结构以及由于体系结构方面的差异带 来的全新服务功能，下一篇文章接着介绍
IIS7架构原理
weixin_30883311的博客
05-28 103
IIS7架构简介： 1：Windows进程激活服务（WAS），使网站使用HTTP和HTTPS以外的其他协议。 　　Windows 进程激活服务通过删除对 HTTP 的依赖关系，可统一 Internet 信息服务 (IIS) 进程模型。通过使用非 HTTP 协议，以前只可用于 HTTP 应用程序的 IIS 的所有功能现在都可用于运行 Windows Communication Foundatio...
Windows操作系统 IIS原理及IIS服务器搭建操作
最新发布
m0_70611788的博客
10-27 5381
Windows操作系统 IIS原理及IIS服务器搭建操作， 希望对大家有帮助
iis7.0与asp.net的运行原理
weixin_30555125的博客
12-10 93
IIS7.0 IIS7.0主要引入了WAS(Windows Process Activation,不同于6.0中的Web Admin Service)，分担了原来w3svc的部分功能，同时为IIS7.0提供了非HTTP协协议的支持，通过适配器接口（Listener Adapter Interface）抽象出针对不同协议（TCP,命名管道，MSMQ）的监听器。 原理图： w3svc 　　...
ASP.NET工作原理与IIS服务器详解
"ASP.NET工作原理及ASP.NET概述" ASP.NET是微软推出的一种用于构建Web应用程序的...其工作流程从用户请求开始，经过IIS、ASP.NET引擎、编译和执行，最后返回响应给用户，这一系列过程确保了Web应用程序的高效运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值