原本今天打算继续写ASP.NET MVC第四天的。但是由于里面涉及到asp.net运行机制的原理，如果不分析一下这里，mvc想说清楚还是挺困难的。既然要提到asp.net运行机制，所以打算还是说详细一点的好。记录mvc第一天的时候就说过，asp.net mvc也是基于asp.net运行机制的（也就是原理）。网上也有很多讲解asp.net运行机制的，我在这里说一下自己的认识，我们开始吧。

我们从web程序的入口开始。那就要先说到iis了，大家都知道，这是web服务软件。将web程序部署到iis过的人都知道，如果不做任何处理，我们写的webform是不能运行的。为什么非要执行aspnet_regiis才可以呢？我们看一下电脑路径C:\Windows\Microsoft.NET\Framework\v4.0.30319，aspnet_regiis.exe就在这里路径下。我们简单说一下原因，看下iis的历史，在百度上没有查到iis软件发布的年限，但至少iis在windows 2000的时候就存在了，而我们的.net framework在2002-02-13的时候才发布1.0版本，是啊，我们都知道微软很厉害，但就是在厉害他也不会强大到可以预测几年后的软件运行机制吧。也就是说iis对.net framework还说就是个“古董”,他不可能会知道.net framewrok运行机制，更不可能知道asp.net的运行机制。早起的iis也只能处理静态页面，也就类似于html，js，图片之类的东西。但现在如果我们想将asp.net 程序部署到iis上怎么办呢？对，扩展，使用扩展程序，我们运行aspnet_regiis.exe也就是将扩展程序（aspnet_isapi）注入到iis中，这样iis就可以处理了？---------哈哈，iis还是处理处理不了asp.net程序，但是后注入的程序可以告诉iis，我扩展程序可以处理什么样的程序，你如果处理不了，可以尝试交给我处理。

看一下上面说到的路经下面有个aspnet_isapi.dll，我们只是简单的说一下这里，这个dll是使用c/c++写的，并不是c#写的，所以我们无法反编译成c#代码。这是个承上启下的动态库，因为c/c++并不是我们考虑的范围内，我们直接认为这个程序将请求交给我们“在乎”的程序，下面我们开始反编译我们“在乎”程序。反编译工具中查找ISAPIRuntime这个类，下面是我反编译出来的结果这个类是system.web程序集下的类

 public sealed class ISAPIRuntime : MarshalByRefObject, IISAPIRuntime, IISAPIRuntime2, IRegisteredObject

 {

     // Fields

     private static int _isThisAppDomainRemovedFromUnmanagedTable;

     private const int WORKER_REQUEST_TYPE_IN_PROC = ;

     private const int WORKER_REQUEST_TYPE_IN_PROC_VERSION_2 = ;

     private const int WORKER_REQUEST_TYPE_OOP = ;

     // Methods

     [SecurityPermission(SecurityAction.Demand, Unrestricted=true)]

     public ISAPIRuntime();

     [SecurityPermission(SecurityAction.LinkDemand, Unrestricted=true)]

     public void DoGCCollect();

     public override object InitializeLifetimeService();

     [SecurityPermission(SecurityAction.LinkDemand, Unrestricted=true)]

     public int ProcessRequest(IntPtr ecb, int iWRType);

     internal static void RemoveThisAppDomainFromUnmanagedTable();

     [SecurityPermission(SecurityAction.LinkDemand, Unrestricted=true)]

     public void StartProcessing();

     [SecurityPermission(SecurityAction.LinkDemand, Unrestricted=true)]

     public void StopProcessing();

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     void IISAPIRuntime2.DoGCCollect();

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     int IISAPIRuntime2.ProcessRequest(IntPtr ecb, int iWRType);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     void IISAPIRuntime2.StartProcessing();

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     void IISAPIRuntime2.StopProcessing();

     void IRegisteredObject.Stop(bool immediate);

 }

 Expand Methods

其实我贴出代码没有别的意思，就是想用事实说话，过多的内容我们不看，我们只看里面的public int ProcessRequest(IntPtr ecb, int iWRType)处理请求方法。我们先看一下参数类型吧，IntPtr？有调c/c++动态库的人会知道这是c/c++里面指针类型，我们不用过多的考虑。我自己分析的，不知道对不对，正因为这是IntPtr，所以该类应该是调用了c/c++相关的动态库了，不然这里也没有必要用到。这样流程就出来了，IIS——》aspnet_isapi（c/c++相关动态库）——》ISAPIRuntime类；需要提到一点的是，IntPtr是个指针，指针会指向一块内存区域，可能很大，也可能很小。我认为请求的内容放在了这块区域中，从这里面可以获取到浏览器请求头的内容下面是ProcessRequest方法的内容

 [SecurityPermission(SecurityAction.LinkDemand, Unrestricted=true)]

 public int ProcessRequest(IntPtr ecb, int iWRType)

 {

     IntPtr zero = IntPtr.Zero;

     if (iWRType == )

     {

         zero = ecb;

         ecb = UnsafeNativeMethods.GetEcb(zero);

     }

     ISAPIWorkerRequest wr = null;

     try

     {

         bool useOOP = iWRType == ;

         wr = ISAPIWorkerRequest.CreateWorkerRequest(ecb, useOOP);

         wr.Initialize();

         string appPathTranslated = wr.GetAppPathTranslated();

         string appDomainAppPathInternal = HttpRuntime.AppDomainAppPathInternal;

         if ((appDomainAppPathInternal == null) || StringUtil.EqualsIgnoreCase(appPathTranslated, appDomainAppPathInternal))

         {

             HttpRuntime.ProcessRequestNoDemand(wr);

             return ;

         }

         HttpRuntime.ShutdownAppDomain(ApplicationShutdownReason.PhysicalApplicationPathChanged, SR.GetString("Hosting_Phys_Path_Changed", new object[] { appDomainAppPathInternal, appPathTranslated }));

         return ;

     }

     catch (Exception exception)

     {

         try

         {

             WebBaseEvent.RaiseRuntimeError(exception, this);

         }

         catch

         {

         }

         if ((wr == null) || !(wr.Ecb == IntPtr.Zero))

         {

             throw;

         }

         if (zero != IntPtr.Zero)

         {

             UnsafeNativeMethods.SetDoneWithSessionCalled(zero);

         }

         if (exception is ThreadAbortException)

         {

             Thread.ResetAbort();

         }

         return ;

     }

 }

下面我们来分析一下这里面的代码，我们只分析重要的部分。

这里新建了一个 ISAPIWorkerRequest wr = null;类，进行创建封装该对象，wr = ISAPIWorkerRequest.CreateWorkerRequest(ecb, useOOP);上面说了ecb是个指针，里面可以存储很多请求内容的。紧接着对wr进行初始化wr.Initialize();我们着重看HttpRuntime.ProcessRequestNoDemand(wr);注意这里使用的是HttpRuntime，一会我们还会分析该类，现在我们进入ProcessRequestNoDemand方法里面看看。这里面应该是关于多线程模型了

 internal static void ProcessRequestNoDemand(HttpWorkerRequest wr)

 {

     RequestQueue queue = _theRuntime._requestQueue;

     wr.UpdateInitialCounters();

     if (queue != null)

     {

         wr = queue.GetRequestToExecute(wr);

     }

     if (wr != null)

     {

         CalculateWaitTimeAndUpdatePerfCounter(wr);

         wr.ResetStartTime();

         ProcessRequestNow(wr);

     }

 }

这时ISAPIRuntime已经将请求交给HttpRuntime类了，HttpRuntime类调用RequestQueue queue = _theRuntime._requestQueue;该类试图获取请求处理队列，我们可以简单的认为服务器在求情一个线程来处理该次浏览器的请求。wr = queue.GetRequestToExecute(wr);我们进入到GetRequestToExecute方法，

 internal HttpWorkerRequest GetRequestToExecute(HttpWorkerRequest wr)

 {

     int num;

     int num2;

     int num3;

     ThreadPool.GetAvailableThreads(out num, out num2);

     if (this._iis6)

     {

         num3 = num;

     }

     else

     {

         num3 = (num2 > num) ? num : num2;

     }

     if ((num3 < this._minExternFreeThreads) || (this._count != ))

     {

         bool isLocal = IsLocal(wr);

         if ((isLocal && (num3 >= this._minLocalFreeThreads)) && (this._count == ))

         {

             return wr;

         }

         if (this._count >= this._queueLimit)

         {

             HttpRuntime.RejectRequestNow(wr, false);

             return null;

         }

         this.QueueRequest(wr, isLocal);

         if (num3 >= this._minExternFreeThreads)

         {

             wr = this.DequeueRequest(false);

             return wr;

         }

         if (num3 >= this._minLocalFreeThreads)

         {

             wr = this.DequeueRequest(true);

             return wr;

         }

         wr = null;

         this.ScheduleMoreWorkIfNeeded();

     }

     return wr;

 }

当然服务器不可能只有一个求情，如果同时有多个用户请求，这时队列中就可能没有线程可响应此次请求，在这里面就会调用this.ScheduleMoreWorkIfNeeded();从线程池中拿出一个来处理请求。下面我们返回ProcessRequestNoDemand（）方法，该方法调用了ProcessRequestNow(wr);处理请求。

 internal static void ProcessRequestNow(HttpWorkerRequest wr)

 {

     _theRuntime.ProcessRequestInternal(wr);

 }

我们只看ProcessRequestNow（）方法

这个方法又调用了HttpRuntime的ProcessRequestInternal方法，接下来我们开始分析HttpRuntme类，

 public sealed class HttpRuntime

 {

     // Fields

     private int _activeRequestCount;

     private bool _apartmentThreading;

     private string _appDomainAppId;

     private string _appDomainAppPath;

     private VirtualPath _appDomainAppVPath;

     private string _appDomainId;

     private Timer _appDomainShutdownTimer;

     private WaitCallback _appDomainUnloadallback;

     private byte[] _appOfflineMessage;

     private HttpWorkerRequest.EndOfSendNotification _asyncEndOfSendCallback;

     private bool _beforeFirstRequest;

     private CacheInternal _cacheInternal;

     private Cache _cachePublic;

     private string _clientScriptPhysicalPath;

     private string _clientScriptVirtualPath;

     private string _codegenDir;

     private bool _configInited;

     private bool _debuggingEnabled;

     private static string _DefaultPhysicalPathOnMapPathFailure;

     private bool _disableProcessRequestInApplicationTrust;

     private volatile bool _disposingHttpRuntime;

     private bool _enableHeaderChecking;

     private static bool _enablePrefetchOptimization;

     private FileChangesMonitor _fcm;

     private bool _firstRequestCompleted;

     private DateTime _firstRequestStartTime;

     private bool _fusionInited;

     private AsyncCallback _handlerCompletionCallback;

     private bool _hostingInitFailed;

     private string _hostSecurityPolicyResolverType;

     private static Version _iisVersion;

     private Exception _initializationError;

     private bool _isLegacyCas;

     private bool _isOnUNCShare;

     private DateTime _lastShutdownAttemptTime;

     private NamedPermissionSet _namedPermissionSet;

     private PolicyLevel _policyLevel;

     private bool _processRequestInApplicationTrust;

     private Profiler _profiler;

     private AsyncCallback _requestNotificationCompletionCallback;

     private RequestQueue _requestQueue;

     private bool _shutdownInProgress;

     private string _shutDownMessage;

     private ApplicationShutdownReason _shutdownReason;

     private string _shutDownStack;

     private bool _shutdownWebEventRaised;

     private string _tempDir;

     private static HttpRuntime _theRuntime;

     private RequestTimeoutManager _timeoutManager;

     private string _trustLevel;

     private static bool _useIntegratedPipeline;

     private bool _userForcedShutdown;

     private string _wpUserId;

     private static BuildManagerHostUnloadEventHandler AppDomainShutdown;

     private const string AppOfflineFileName = "App_Offline.htm";

     private const string AspNetClientFilesParentVirtualPath = "/aspnet_client/system_web/";

     private const string AspNetClientFilesSubDirectory = "asp.netclientfiles";

     internal const string BinDirectoryName = "bin";

     internal const string BrowsersDirectoryName = "App_Browsers";

     internal const string CodeDirectoryName = "App_Code";

     internal const string codegenDirName = "Temporary ASP.NET Files";

     internal const string DataDirectoryName = "App_Data";

     private static string DirectorySeparatorString;

     private static string DoubleDirectorySeparatorString;

     internal const string GlobalThemesDirectoryName = "Themes";

     internal const string LocalResourcesDirectoryName = "App_LocalResources";

     private const long MaxAppOfflineFileLength = 0x100000L;

     internal const string profileFileName = "profileoptimization.prof";

     internal const string ResourcesDirectoryName = "App_GlobalResources";

     internal static byte[] s_autogenKeys;

     private static Hashtable s_factoryCache;

     private static FactoryGenerator s_factoryGenerator;

     private static object s_factoryLock;

     private static bool s_initialized;

     private static bool s_initializedFactory;

     private static string s_installDirectory;

     private static char[] s_InvalidPhysicalPathChars;

     private static bool s_isEngineLoaded;

     internal const string ThemesDirectoryName = "App_Themes";

     internal const string WebRefDirectoryName = "App_WebReferences";

     // Events

     internal static  event BuildManagerHostUnloadEventHandler AppDomainShutdown;

     // Methods

     static HttpRuntime();

     [SecurityPermission(SecurityAction.LinkDemand, Unrestricted=true)]

     public HttpRuntime();

     internal static void AddAppDomainTraceMessage(string message);

     private void AppDomainShutdownTimerCallback(object state);

     private static void CalculateWaitTimeAndUpdatePerfCounter(HttpWorkerRequest wr);

     [FileIOPermission(SecurityAction.Assert, Unrestricted=true)]

     private void CheckAccessToTempDirectory();

     internal static void CheckApplicationEnabled();

     internal static void CheckAspNetHostingPermission(AspNetHostingPermissionLevel level, string errorMessageId);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     internal static void CheckFilePermission(string path);

     internal static void CheckFilePermission(string path, bool writePermissions);

     internal static void CheckVirtualFilePermission(string virtualPath);

     [SecurityPermission(SecurityAction.Demand, Unrestricted=true)]

     public static void Close();

     internal static void CoalesceNotifications();

     private void CreateCache();

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     internal static object CreateNonPublicInstance(Type type);

     [PermissionSet(SecurityAction.Assert, Unrestricted=true)]

     internal static object CreateNonPublicInstance(Type type, object[] args);

     private static PolicyLevel CreatePolicyLevel(string configFile, string appDir, string binDir, string strOriginUrl, out bool foundGacToken);

     internal static object CreatePublicInstance(Type type);

     internal static object CreatePublicInstance(Type type, object[] args);

     internal static void DecrementActivePipelineCount();

     private void Dispose();

     private void DisposeAppDomainShutdownTimer();

     private void EndOfSendCallback(HttpWorkerRequest wr, object arg);

     private void EnsureAccessToApplicationDirectory();

     private void EnsureFirstRequestInit(HttpContext context);

     internal static void FailIfNoAPTCABit(Type t, XmlNode node);

     internal static void FailIfNoAPTCABit(Type t, ElementInformation elemInfo, string propertyName);

     internal static object FastCreatePublicInstance(Type type);

     internal static void FinishPipelineRequest(HttpContext context);

     private void FinishRequest(HttpWorkerRequest wr, HttpContext context, Exception e);

     private void FinishRequestNotification(IIS7WorkerRequest wr, HttpContext context, ref RequestNotificationStatus status);

     private void FirstRequestInit(HttpContext context);

     internal static void ForceStaticInit();

     private static string GetAppDomainString(string key);

     internal static CacheInternal GetCacheInternal(bool createIfDoesNotExist);

     private static string GetCurrentUserName();

     internal static string GetGacLocation();

     private void GetInitConfigSections(out CacheSection cacheSection, out TrustSection trustSection, out SecurityPolicySection securityPolicySection, out CompilationSection compilationSection, out HostingEnvironmentSection hostingEnvironmentSection, out Exception initException);

     [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Unrestricted)]

     public static NamedPermissionSet GetNamedPermissionSet();

     internal static string GetRelaxedMapPathResult(string originalResult);

     internal static string GetSafePath(string path);

     internal static bool HasAppPathDiscoveryPermission();

     private static bool HasAPTCABit(Assembly assembly);

     internal static bool HasAspNetHostingPermission(AspNetHostingPermissionLevel level);

     internal static bool HasDbPermission(DbProviderFactory factory);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     internal static bool HasFilePermission(string path);

     internal static bool HasFilePermission(string path, bool writePermissions);

     internal static bool HasPathDiscoveryPermission(string path);

     internal static bool HasUnmanagedPermission();

     internal static bool HasWebPermission(Uri uri);

     private void HostingInit(HostingEnvironmentFlags hostingFlags, PolicyLevel policyLevel, Exception appDomainCreationException);

     internal static void IncrementActivePipelineCount();

     private void Init();

     private void InitApartmentThreading();

     private void InitDebuggingSupport();

     private void InitFusion(HostingEnvironmentSection hostingEnvironmentSection);

     private void InitHeaderEncoding();

     private static void InitHttpConfiguration();

     private void InitializeHealthMonitoring();

     internal static void InitializeHostingFeatures(HostingEnvironmentFlags hostingFlags, PolicyLevel policyLevel, Exception appDomainCreationException);

     private bool InitiateShutdownOnce();

     private void InitRequestQueue();

     private void InitTrace(HttpContext context);

     internal static bool IsPathWithinAppRoot(string path);

     internal static bool IsTypeAccessibleFromPartialTrust(Type t);

     internal static bool IsTypeAllowedInConfig(Type t);

     internal static string MakeFileUrl(string path);

     internal static void OnAppDomainShutdown(BuildManagerHostUnloadEventArgs e);

     private void OnAppOfflineFileChange(object sender, FileChangeEvent e);

     internal static void OnConfigChange(string message);

     private void OnCriticalDirectoryChange(object sender, FileChangeEvent e);

     private void OnHandlerCompletion(IAsyncResult ar);

     private void OnRequestNotificationCompletion(IAsyncResult ar);

     private void OnRequestNotificationCompletionHelper(IAsyncResult ar);

     private void OnSecurityPolicyFileChange(object sender, FileChangeEvent e);

     internal static void PopulateIISVersionInformation();

     [PermissionSet(SecurityAction.Assert, Unrestricted=true)]

     private void PreloadAssembliesFromBin();

     private void PreloadAssembliesFromBinRecursive(DirectoryInfo dirInfo);

     [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Medium)]

     public static void ProcessRequest(HttpWorkerRequest wr);

     private void ProcessRequestInternal(HttpWorkerRequest wr);

     internal static void ProcessRequestNoDemand(HttpWorkerRequest wr);

     internal static RequestNotificationStatus ProcessRequestNotification(IIS7WorkerRequest wr, HttpContext context);

     private RequestNotificationStatus ProcessRequestNotificationPrivate(IIS7WorkerRequest wr, HttpContext context);

     internal static void ProcessRequestNow(HttpWorkerRequest wr);

     private void RaiseShutdownWebEventOnce();

     internal static void RecoverFromUnexceptedAppDomainUnload();

     private void RejectRequestInternal(HttpWorkerRequest wr, bool silent);

     internal static void RejectRequestNow(HttpWorkerRequest wr, bool silent);

     private void RelaxMapPathIfRequired();

     [PermissionSet(SecurityAction.Assert, Unrestricted=true)]

     private void ReleaseResourcesAndUnloadAppDomain(object state);

     internal static void ReportAppOfflineErrorMessage(HttpResponse response, byte[] appOfflineMessage);

     internal static void RestrictIISFolders(HttpContext context);

     private void SetAutoConfigLimits(ProcessModelSection pmConfig);

     private static void SetAutogenKeys();

     [SecurityPermission(SecurityAction.Assert, ControlThread=true)]

     internal static void SetCurrentThreadCultureWithAssert(CultureInfo cultureInfo);

     private static void SetExecutionTimePerformanceCounter(HttpContext context);

     internal static void SetShutdownMessage(string message);

     internal static void SetShutdownReason(ApplicationShutdownReason reason, string message);

     private void SetThreadPoolLimits();

     private void SetTrustLevel(TrustSection trustSection, SecurityPolicySection securityPolicySection);

     private void SetTrustParameters(TrustSection trustSection, SecurityPolicySection securityPolicySection, PolicyLevel policyLevel);

     private void SetUpCodegenDirectory(CompilationSection compilationSection);

     private void SetUpDataDirectory();

     internal static void SetUserForcedShutdown();

     private static bool ShutdownAppDomain(string stackTrace);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     internal static bool ShutdownAppDomain(ApplicationShutdownReason reason, string message);

     internal static bool ShutdownAppDomainWithStackTrace(ApplicationShutdownReason reason, string message, string stackTrace);

     private void StartAppDomainShutdownTimer();

     internal static void StartListeningToLocalResourcesDirectory(VirtualPath virtualDir);

     private void StartMonitoringDirectoryRenamesAndBinDirectory();

     private static void StaticInit();

     public static void UnloadAppDomain();

     private static void UpdatePerfCounters(int statusCode);

     private void WaitForRequestsToFinish(int waitTimeoutMs);

     // Properties

     internal static bool ApartmentThreading { get; }

     public static string AppDomainAppId { get; }

     public static string AppDomainAppPath { get; }

     internal static string AppDomainAppPathInternal { get; }

     public static string AppDomainAppVirtualPath { get; }

     internal static VirtualPath AppDomainAppVirtualPathObject { get; }

     internal static string AppDomainAppVirtualPathString { get; }

     public static string AppDomainId { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries"), AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.High)] get; }

     internal static string AppDomainIdInternal { get; }

     internal static byte[] AppOfflineMessage { get; }

     public static string AspClientScriptPhysicalPath { get; }

     internal static string AspClientScriptPhysicalPathInternal { get; }

     public static string AspClientScriptVirtualPath { get; }

     public static string AspInstallDirectory { get; }

     internal static string AspInstallDirectoryInternal { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     public static string BinDirectory { get; }

     internal static string BinDirectoryInternal { get; }

     public static Cache Cache { get; }

     internal static CacheInternal CacheInternal { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     public static string ClrInstallDirectory { get; }

     internal static string ClrInstallDirectoryInternal { get; }

     internal static VirtualPath CodeDirectoryVirtualPath { get; }

     public static string CodegenDir { get; }

     internal static string CodegenDirInternal { get; }

     internal static bool ConfigInited { get; }

     internal static bool DebuggingEnabled { get; }

     internal static bool DisableProcessRequestInApplicationTrust { get; }

     internal static bool EnableHeaderChecking { get; }

     internal static bool EnablePrefetchOptimization { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     internal static FileChangesMonitor FileChangesMonitor { get; }

     internal static bool FusionInited { get; }

     internal static bool HostingInitFailed { get; }

     internal static string HostSecurityPolicyResolverType { get; }

     public static Version IISVersion { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     internal static Exception InitializationException { get; set; }

     internal static bool IsAspNetAppDomain { get; }

     internal static bool IsEngineLoaded { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     internal static bool IsFullTrust { get; }

     internal static bool IsLegacyCas { get; }

     internal static bool IsMapPathRelaxed { get; }

     public static bool IsOnUNCShare { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries"), AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Low)] get; }

     internal static bool IsOnUNCShareInternal { get; }

     internal static bool IsTrustLevelInitialized { get; }

     private DateTime LastShutdownAttemptTime { get; set; }

     public static string MachineConfigurationDirectory { get; }

     internal static string MachineConfigurationDirectoryInternal { get; }

     internal static NamedPermissionSet NamedPermissionSet { get; }

     internal static PolicyLevel PolicyLevel { get; }

     internal static bool ProcessRequestInApplicationTrust { get; }

     internal static Profiler Profile { get; }

     internal static RequestTimeoutManager RequestTimeoutManager { get; }

     internal static VirtualPath ResourcesDirectoryVirtualPath { get; }

     internal static bool ShutdownInProgress { get; }

     internal static ApplicationShutdownReason ShutdownReason { get; }

     public static Version TargetFramework { get; }

     internal static string TempDirInternal { get; }

     internal static string TrustLevel { get; }

     internal static bool UseIntegratedPipeline { [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")] get; }

     public static bool UsingIntegratedPipeline { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     internal static VirtualPath WebRefDirectoryVirtualPath { get; }

     internal static string WpUserId { get; }

 }

 Expand Methods

看ProcessRequestInternal（）方法

 private void ProcessRequestInternal(HttpWorkerRequest wr)

 {

     Interlocked.Increment(ref this._activeRequestCount);

     if (this._disposingHttpRuntime)

     {

         try

         {

             wr.SendStatus(0x1f7, "Server Too Busy");

             wr.SendKnownResponseHeader(, "text/html; charset=utf-8");

             byte[] bytes = Encoding.ASCII.GetBytes("<html><body>Server Too Busy</body></html>");

             wr.SendResponseFromMemory(bytes, bytes.Length);

             wr.FlushResponse(true);

             wr.EndOfRequest();

         }

         finally

         {

             Interlocked.Decrement(ref this._activeRequestCount);

         }

     }

     else

     {

         HttpContext context;

         try

         {

             context = new HttpContext(wr, false);

         }

         catch

         {

             try

             {

                 wr.SendStatus(, "Bad Request");

                 wr.SendKnownResponseHeader(, "text/html; charset=utf-8");

                 byte[] data = Encoding.ASCII.GetBytes("<html><body>Bad Request</body></html>");

                 wr.SendResponseFromMemory(data, data.Length);

                 wr.FlushResponse(true);

                 wr.EndOfRequest();

                 return;

             }

             finally

             {

                 Interlocked.Decrement(ref this._activeRequestCount);

             }

         }

         wr.SetEndOfSendNotification(this._asyncEndOfSendCallback, context);

         HostingEnvironment.IncrementBusyCount();

         try

         {

             try

             {

                 this.EnsureFirstRequestInit(context);

             }

             catch

             {

                 if (!context.Request.IsDebuggingRequest)

                 {

                     throw;

                 }

             }

             context.Response.InitResponseWriter();

             IHttpHandler applicationInstance = HttpApplicationFactory.GetApplicationInstance(context);

             if (applicationInstance == null)

             {

                 throw new HttpException(SR.GetString("Unable_create_app_object"));

             }

             if (EtwTrace.IsTraceEnabled(, ))

             {

                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_START_HANDLER, context.WorkerRequest, applicationInstance.GetType().FullName, "Start");

             }

             if (applicationInstance is IHttpAsyncHandler)

             {

                 IHttpAsyncHandler handler2 = (IHttpAsyncHandler) applicationInstance;

                 context.AsyncAppHandler = handler2;

                 handler2.BeginProcessRequest(context, this._handlerCompletionCallback, context);

             }

             else

             {

                 applicationInstance.ProcessRequest(context);

                 this.FinishRequest(context.WorkerRequest, context, null);

             }

         }

         catch (Exception exception)

         {

             context.Response.InitResponseWriter();

             this.FinishRequest(wr, context, exception);

         }

     }

 }

在这里创建了上下文 HttpContext context;对象，使用wr（wr中封装了请求信息）对象创建了上下文对象 context = new HttpContext(wr, false);

IHttpHandler applicationInstance = HttpApplicationFactory.GetApplicationInstance(context);使用HttpApplicationFactory创建HttpApplication对象，applicationInstance.ProcessRequest(context);在这个方法中会调用近20几个是事件，该对象在后面的事件中通过反射创建请求页面类的对象在第7个事件和第8个事件中间通过反射创建前台页面类对象，后续的事件之间又调用页面类对象的ProcessRequest方法，这就是我们写的asp.net程序后台类为什么有ProcessRequest方法了，我们应该知道前台页面类继承后台页面类，我在这里再贴一下HttpApplication类的代码
 [ToolboxItem(false)]

 public class HttpApplication : IComponent, IDisposable, IHttpAsyncHandler, IHttpHandler, IRequestCompletedNotifier, ISyncContext

 {

     // Fields

     private EventArgs _appEvent;

     private bool _appLevelAutoCulture;

     private bool _appLevelAutoUICulture;

     private CultureInfo _appLevelCulture;

     private CultureInfo _appLevelUICulture;

     private RequestNotification _appPostNotifications;

     private RequestNotification _appRequestNotifications;

     private HttpAsyncResult _ar;

     private AsyncAppEventHandlersTable _asyncEvents;

     private HttpContext _context;

     private string _currentModuleCollectionKey;

     private static readonly DynamicModuleRegistry _dynamicModuleRegistry;

     private byte[] _entityBuffer;

     private EventHandlerList _events;

     private Hashtable _handlerFactories;

     private ArrayList _handlerRecycleList;

     private bool _hideRequestResponse;

     private HttpContext _initContext;

     private bool _initInternalCompleted;

     private static bool _initSpecialCompleted;

     private Exception _lastError;

     private HttpModuleCollection _moduleCollection;

     private static List<ModuleConfigurationInfo> _moduleConfigInfo;

     private PipelineModuleStepContainer[] _moduleContainers;

     private static Hashtable _moduleIndexMap;

     private Dictionary<string, RequestNotification> _pipelineEventMasks;

     private WaitCallback _resumeStepsWaitCallback;

     private CultureInfo _savedAppLevelCulture;

     private CultureInfo _savedAppLevelUICulture;

     private HttpSessionState _session;

     private ISite _site;

     private HttpApplicationState _state;

     private StepManager _stepManager;

     private bool _timeoutManagerInitialized;

     internal CountdownTask ApplicationInstanceConsumersCounter;

     internal static readonly string AutoCulture;

     private static readonly object EventAcquireRequestState;

     private static readonly object EventAuthenticateRequest;

     private static readonly object EventAuthorizeRequest;

     private static readonly object EventBeginRequest;

     private static readonly object EventDefaultAuthentication;

     private static readonly object EventDisposed;

     private static readonly object EventEndRequest;

     private static readonly object EventErrorRecorded;

     private static readonly object EventLogRequest;

     private static readonly object EventMapRequestHandler;

     private static readonly object EventPostAcquireRequestState;

     private static readonly object EventPostAuthenticateRequest;

     private static readonly object EventPostAuthorizeRequest;

     private static readonly object EventPostLogRequest;

     private static readonly object EventPostMapRequestHandler;

     private static readonly object EventPostReleaseRequestState;

     private static readonly object EventPostRequestHandlerExecute;

     private static readonly object EventPostResolveRequestCache;

     private static readonly object EventPostUpdateRequestCache;

     private static readonly object EventPreRequestHandlerExecute;

     private static readonly object EventPreSendRequestContent;

     private static readonly object EventPreSendRequestHeaders;

     private static readonly object EventReleaseRequestState;

     private static readonly object EventRequestCompleted;

     private static readonly object EventResolveRequestCache;

     private static readonly object EventUpdateRequestCache;

     internal const string IMPLICIT_FILTER_MODULE = "AspNetFilterModule";

     internal const string IMPLICIT_HANDLER = "ManagedPipelineHandler";

     internal const string MANAGED_PRECONDITION = "managedHandler";

     // Events

     public event EventHandler AcquireRequestState;

     public event EventHandler AuthenticateRequest;

     public event EventHandler AuthorizeRequest;

     public event EventHandler BeginRequest;

     internal event EventHandler DefaultAuthentication;

     public event EventHandler Disposed;

     public event EventHandler EndRequest;

     public event EventHandler Error;

     public event EventHandler LogRequest;

     public event EventHandler MapRequestHandler;

     public event EventHandler PostAcquireRequestState;

     public event EventHandler PostAuthenticateRequest;

     public event EventHandler PostAuthorizeRequest;

     public event EventHandler PostLogRequest;

     public event EventHandler PostMapRequestHandler;

     public event EventHandler PostReleaseRequestState;

     public event EventHandler PostRequestHandlerExecute;

     public event EventHandler PostResolveRequestCache;

     public event EventHandler PostUpdateRequestCache;

     public event EventHandler PreRequestHandlerExecute;

     public event EventHandler PreSendRequestContent;

     public event EventHandler PreSendRequestHeaders;

     public event EventHandler ReleaseRequestState;

     public event EventHandler RequestCompleted;

     public event EventHandler ResolveRequestCache;

     public event EventHandler UpdateRequestCache;

     // Methods

     static HttpApplication();

     public HttpApplication();

     internal void AcquireNotifcationContextLock(ref bool locked);

     private void AddEventMapping(string moduleName, RequestNotification requestNotification, bool isPostNotification, IExecutionStep step);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnAcquireRequestStateAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnAcquireRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnAuthenticateRequestAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnAuthenticateRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnAuthorizeRequestAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnAuthorizeRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnBeginRequestAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnBeginRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnEndRequestAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnEndRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     public void AddOnLogRequestAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnLogRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     public void AddOnMapRequestHandlerAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnMapRequestHandlerAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnPostAcquireRequestStateAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPostAcquireRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnPostAuthenticateRequestAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPostAuthenticateRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnPostAuthorizeRequestAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPostAuthorizeRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     public void AddOnPostLogRequestAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPostLogRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnPostMapRequestHandlerAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPostMapRequestHandlerAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnPostReleaseRequestStateAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPostReleaseRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnPostRequestHandlerExecuteAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPostRequestHandlerExecuteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnPostResolveRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPostResolveRequestCacheAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnPostUpdateRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPostUpdateRequestCacheAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnPreRequestHandlerExecuteAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnPreRequestHandlerExecuteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnReleaseRequestStateAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnReleaseRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnResolveRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnResolveRequestCacheAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     public void AddOnUpdateRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh);

     public void AddOnUpdateRequestCacheAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

     private void AddSendResponseEventHookup(object key, Delegate handler);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     internal void AddSyncEventHookup(object key, Delegate handler, RequestNotification notification);

     private void AddSyncEventHookup(object key, Delegate handler, RequestNotification notification, bool isPostNotification);

     internal void AssignContext(HttpContext context);

     internal IAsyncResult BeginProcessRequestNotification(HttpContext context, AsyncCallback cb);

     private void BuildEventMaskDictionary(Dictionary<string, RequestNotification> eventMask);

     private HttpModuleCollection BuildIntegratedModuleCollection(List<ModuleConfigurationInfo> moduleList);

     internal void ClearError();

     public void CompleteRequest();

     private HttpModuleCollection CreateDynamicModules();

     private void CreateEventExecutionSteps(object eventIndex, ArrayList steps);

     internal IExecutionStep CreateImplicitAsyncPreloadExecutionStep();

     public virtual void Dispose();

     internal void DisposeInternal();

     internal RequestNotificationStatus EndProcessRequestNotification(IAsyncResult result);

     internal void EnsureReleaseState();

     internal Exception ExecuteStep(IExecutionStep step, ref bool completedSynchronously);

     private IEnumerable<ModuleConfigurationInfo> GetConfigInfoForDynamicModules();

     [SecurityPermission(SecurityAction.Assert, ControlPrincipal=true)]

     internal static WindowsIdentity GetCurrentWindowsIdentityWithAssert();

     private IHttpHandlerFactory GetFactory(string type);

     private IHttpHandlerFactory GetFactory(HttpHandlerAction mapping);

     internal static string GetFallbackCulture(string culture);

     private HttpHandlerAction GetHandlerMapping(HttpContext context, string requestType, VirtualPath path, bool useAppConfig);

     private HttpModuleCollection GetModuleCollection(IntPtr appContext);

     private PipelineModuleStepContainer GetModuleContainer(string moduleName);

     public virtual string GetOutputCacheProviderName(HttpContext context);

     public virtual string GetVaryByCustomString(HttpContext context, string custom);

     private bool HasEventSubscription(object eventIndex);

     private void HookupEventHandlersForApplicationAndModules(MethodInfo[] handlers);

     public virtual void Init();

     private void InitAppLevelCulture();

     private void InitIntegratedModules();

     internal void InitInternal(HttpContext context, HttpApplicationState state, MethodInfo[] handlers);

     private void InitModules();

     private void InitModulesCommon();

     internal void InitSpecial(HttpApplicationState state, MethodInfo[] handlers, IntPtr appContext, HttpContext context);

     [ReflectionPermission(SecurityAction.Assert, Flags=ReflectionPermissionFlag.RestrictedMemberAccess)]

     private void InvokeMethodWithAssert(MethodInfo method, int paramCount, object eventSource, EventArgs eventArgs);

     internal IHttpHandler MapHttpHandler(HttpContext context, string requestType, VirtualPath path, string pathTranslated, bool useAppConfig);

     internal IHttpHandler MapIntegratedHttpHandler(HttpContext context, string requestType, VirtualPath path, string pathTranslated, bool useAppConfig, bool convertNativeStaticFileModule);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     internal ThreadContext OnThreadEnter();

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     internal ThreadContext OnThreadEnter(bool setImpersonationContext);

     private ThreadContext OnThreadEnterPrivate(bool setImpersonationContext);

     private void ProcessEventSubscriptions(out RequestNotification requestNotifications, out RequestNotification postRequestNotifications);

     internal void ProcessSpecialRequest(HttpContext context, MethodInfo method, int paramCount, object eventSource, EventArgs eventArgs, HttpSessionState session);

     internal void RaiseErrorWithoutContext(Exception error);

     private void RaiseOnError();

     internal void RaiseOnPreSendRequestContent();

     internal void RaiseOnPreSendRequestHeaders();

     private void RaiseOnRequestCompleted();

     private void RecordError(Exception error);

     private void RecycleHandlers();

     private void RegisterEventSubscriptionsWithIIS(IntPtr appContext, HttpContext context, MethodInfo[] handlers);

     private void RegisterIntegratedEvent(IntPtr appContext, string moduleName, RequestNotification requestNotifications, RequestNotification postRequestNotifications, string moduleType, string modulePrecondition, bool useHighPriority);

     public static void RegisterModule(Type moduleType);

     internal static void RegisterModuleInternal(Type moduleType);

     internal void ReleaseAppInstance();

     internal void ReleaseNotifcationContextLock();

     private void RemoveSendResponseEventHookup(object key, Delegate handler);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     internal void RemoveSyncEventHookup(object key, Delegate handler, RequestNotification notification);

     internal void RemoveSyncEventHookup(object key, Delegate handler, RequestNotification notification, bool isPostNotification);

     private void RestoreAppLevelCulture();

     private void ResumeSteps(Exception error);

     private void ResumeStepsFromThreadPoolThread(Exception error);

     private void ResumeStepsWaitCallback(object error);

     private void SetAppLevelCulture();

     [SecurityPermission(SecurityAction.Assert, ControlPrincipal=true)]

     internal static void SetCurrentPrincipalWithAssert(IPrincipal user);

     IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData);

     void IHttpAsyncHandler.EndProcessRequest(IAsyncResult result);

     void IHttpHandler.ProcessRequest(HttpContext context);

     [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

     ISyncContextLock ISyncContext.Enter();

     private void ThrowIfEventBindingDisallowed();

     // Properties

     internal EventArgs AppEvent { get; set; }

     [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]

     public HttpApplicationState Application { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     private AsyncAppEventHandlersTable AsyncEvents { get; }

     internal HttpAsyncResult AsyncResult { get; set; }

     [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]

     public HttpContext Context { get; }

     internal string CurrentModuleCollectionKey { get; }

     private PipelineModuleStepContainer CurrentModuleContainer { get; }

     internal byte[] EntityBuffer { get; }

     protected EventHandlerList Events { get; }

     internal static List<ModuleConfigurationInfo> IntegratedModuleList { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     private bool IsContainerInitalizationAllowed { get; }

     internal bool IsRequestCompleted { get; }

     internal Exception LastError { get; }

     private PipelineModuleStepContainer[] ModuleContainers { get; }

     [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

     public HttpModuleCollection Modules { [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.High)] get; }

     [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]

     public HttpRequest Request { get; }

     [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

     public HttpResponse Response { get; }

     [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]

     public HttpServerUtility Server { get; }

     [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

     public HttpSessionState Session { get; }

     [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

     public ISite Site { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] set; }

     bool IHttpHandler.IsReusable { get; }

     bool IRequestCompletedNotifier.IsRequestCompleted { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     HttpContext ISyncContext.HttpContext { get; }

     [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

     public IPrincipal User { get; }

     // Nested Types

     internal class ApplicationStepManager : HttpApplication.StepManager

     {

         // Fields

         private int _currentStepIndex;

         private int _endRequestStepIndex;

         private HttpApplication.IExecutionStep[] _execSteps;

         private int _numStepCalls;

         private int _numSyncStepCalls;

         private WaitCallback _resumeStepsWaitCallback;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal ApplicationStepManager(HttpApplication app);

         internal override void BuildSteps(WaitCallback stepCallback);

         internal override void InitRequest();

         [DebuggerStepperBoundary]

         internal override void ResumeSteps(Exception error);

     }

     internal class AsyncAppEventHandler

     {

         // Fields

         private ArrayList _beginHandlers;

         private int _count;

         private ArrayList _endHandlers;

         private ArrayList _stateObjects;

         // Methods

         internal AsyncAppEventHandler();

         internal void Add(BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

         internal void CreateExecutionSteps(HttpApplication app, ArrayList steps);

         internal void Reset();

         // Properties

         internal int Count { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     }

     internal class AsyncAppEventHandlersTable

     {

         // Fields

         private Hashtable _table;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         public AsyncAppEventHandlersTable();

         internal void AddHandler(object eventId, BeginEventHandler beginHandler, EndEventHandler endHandler, object state, RequestNotification requestNotification, bool isPost, HttpApplication app);

         // Properties

         internal HttpApplication.AsyncAppEventHandler this[object eventId] { get; }

     }

     internal class AsyncEventExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         private HttpApplication.AsyncStepCompletionInfo _asyncStepCompletionInfo;

         private BeginEventHandler _beginHandler;

         private AsyncCallback _completionCallback;

         private EndEventHandler _endHandler;

         private object _state;

         private bool _sync;

         private string _targetTypeStr;

         // Methods

         internal AsyncEventExecutionStep(HttpApplication app, BeginEventHandler beginHandler, EndEventHandler endHandler, object state);

         internal AsyncEventExecutionStep(HttpApplication app, BeginEventHandler beginHandler, EndEventHandler endHandler, object state, bool useIntegratedPipeline);

         private void OnAsyncEventCompletion(IAsyncResult ar);

         private void ResumeSteps(Exception error);

         [PermissionSet(SecurityAction.Assert, Unrestricted=true)]

         private void ResumeStepsWithAssert(Exception error);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

     [StructLayout(LayoutKind.Sequential)]

     private struct AsyncStepCompletionInfo

     {

         private volatile int _asyncState;

         private ExceptionDispatchInfo _error;

         private const int ASYNC_STATE_NONE = ;

         private const int ASYNC_STATE_BEGIN_UNWOUND = ;

         private const int ASYNC_STATE_CALLBACK_COMPLETED = ;

         public bool RegisterAsyncCompletion(Exception error);

         public void RegisterBeginUnwound(IAsyncResult asyncResult, out bool operationCompleted, out bool mustCallEndHandler);

         public void ReportError();

         public void Reset();

     }

     internal class CallFilterExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal CallFilterExecutionStep(HttpApplication app);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

     internal class CallHandlerExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         private HttpApplication.AsyncStepCompletionInfo _asyncStepCompletionInfo;

         private AsyncCallback _completionCallback;

         private IHttpAsyncHandler _handler;

         private bool _sync;

         // Methods

         internal CallHandlerExecutionStep(HttpApplication app);

         private void OnAsyncHandlerCompletion(IAsyncResult ar);

         private void ResumeSteps(Exception error);

         [PermissionSet(SecurityAction.Assert, Unrestricted=true)]

         private void ResumeStepsWithAssert(Exception error);

         private static void SuppressPostEndRequestIfNecessary(HttpContext context);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

     internal class CancelModuleException

     {

         // Fields

         private bool _timeout;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal CancelModuleException(bool timeout);

         // Properties

         internal bool Timeout { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     }

     internal interface IExecutionStep

     {

         // Methods

         void Execute();

         // Properties

         bool CompletedSynchronously { get; }

         bool IsCancellable { get; }

     }

     internal class MapHandlerExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal MapHandlerExecutionStep(HttpApplication app);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

     internal class MaterializeHandlerExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal MaterializeHandlerExecutionStep(HttpApplication app);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

     internal class NoopExecutionStep : HttpApplication.IExecutionStep

     {

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal NoopExecutionStep();

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

     internal class PipelineStepManager : HttpApplication.StepManager

     {

         // Fields

         private WaitCallback _resumeStepsWaitCallback;

         private bool _validateInputCalled;

         private bool _validatePathCalled;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal PipelineStepManager(HttpApplication app);

         internal override void BuildSteps(WaitCallback stepCallback);

         internal override void InitRequest();

         [DebuggerStepperBoundary]

         internal override void ResumeSteps(Exception error);

         private Exception ValidateHelper(HttpContext context);

     }

     internal class SendResponseExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         private EventHandler _handler;

         private bool _isHeaders;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal SendResponseExecutionStep(HttpApplication app, EventHandler handler, bool isHeaders);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

     internal abstract class StepManager

     {

         // Fields

         protected HttpApplication _application;

         protected bool _requestCompleted;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal StepManager(HttpApplication application);

         internal abstract void BuildSteps(WaitCallback stepCallback);

         internal void CompleteRequest();

         internal abstract void InitRequest();

         internal abstract void ResumeSteps(Exception error);

         // Properties

         internal bool IsCompleted { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

     }

     internal class SyncEventExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         private EventHandler _handler;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal SyncEventExecutionStep(HttpApplication app, EventHandler handler);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         internal EventHandler Handler { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }

         bool HttpApplication.IExecutionStep.CompletedSynchronously { [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")] get; }

         bool HttpApplication.IExecutionStep.IsCancellable { [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")] get; }

     }

     internal class TransitionToWebSocketsExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private readonly HttpApplication _application;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal TransitionToWebSocketsExecutionStep(HttpApplication app);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         public bool CompletedSynchronously { [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; [CompilerGenerated] private set; }

         public bool IsCancellable { get; }

     }

     internal class UrlMappingsExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal UrlMappingsExecutionStep(HttpApplication app);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

     internal class ValidatePathExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal ValidatePathExecutionStep(HttpApplication app);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

     internal class ValidateRequestExecutionStep : HttpApplication.IExecutionStep

     {

         // Fields

         private HttpApplication _application;

         // Methods

         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

         internal ValidateRequestExecutionStep(HttpApplication app);

         void HttpApplication.IExecutionStep.Execute();

         // Properties

         bool HttpApplication.IExecutionStep.CompletedSynchronously { get; }

         bool HttpApplication.IExecutionStep.IsCancellable { get; }

     }

 }

 Expand Methods
  
感兴趣的可以看一下这里面的属性，事件（事件执行顺序并不是写的那个顺序）；下面我画张图，简单描述一下过程

剩下就是页面类执行ProcessRequest的方法了，今天先不说了，太晚了。接下来我们继续mvc也可以了，我们mvc并没有页面类的ProcessRequest方法，以后有时间在说这里吧。

												


											
ASP.NET 运行机制的更多相关文章
	

    
						
  1. ASP.NET运行机制原理
		
    ASP.NET运行机制原理 一.浏览器和服务器的交互原理 (一).浏览器和服务器交互的简单描述: 1.通俗描述:我们平时通过浏览器来访问网站,其实就相当于你通过浏览器去另一台电脑上访问文件一样,只不过 ...
    
		
    2. 
						
  2. ASP.NET运行机制原理  ---浏览器与IIS的交互过程  自己学习 网上查了下别人写的总结的很好  就转过来了 和自己写的还好里嘻嘻
		
    一.浏览器和服务器的交互原理 (一).浏览器和服务器交互的简单描述: 1.通俗描述:我们平时通过浏览器来访问网站,其实就相当于你通过浏览器去访问一台电脑上访问文件一样,只不过浏览器的访问请求是由被访问 ...
    
		
    3. 
						
  3. WebForm页面生命周期及asp.net运行机制
		
    1.先上几张原理图着重理解: 现在针对第四副图原理进行解析: 流程: 1.浏览器发送请求 2.服务器软件(IIS)接收,它最终的目的就是为了向客户输出它请求的动态页面生成的html代码. 3.服务器不 ...
    
		
    4. 
								
  4. 了解认识asp.net运行机制
		
    asp.net  运行机制 下面了解认识httpModule 要创建一个httpModule类 using System;using System.Collections.Generic;using  ...
    
		
    5. 
						
  5. 我对asp.net运行机制的理解
		
    有一本书叫<asp.net 本质论>,作者名叫冠军.我看了几次,都没有坚持看下来.这次连续看完了前三章,然后参考网上的资料,总结下我对.net运行机制的理解. 先上两张图: 看着这两张图, ...
    
		
    6. 
						
  6. ASP.NET 运行机制续（完结）
		
    上一篇说到applicationInstance会执行一些列的事件.下面是我在msdn上找到有关asp.net程序生命周期相关的描述及图片 声明周期的起始 ASP.NET 应用程序的生命周期以浏览器向 ...
    
		
    7. 
						
  7. ASP.NET 运行机制详解
		
    1.浏览器和服务器的交互原理 通俗描述:我们平时通过浏览器来访问网站,其实就相当于你通过浏览器去访问一台电脑上访问文件一样,只不过浏览器的访问请求是由被访问的电脑上的一个 WEB服务器软件来接收处理, ...
    
		
    8. 
						
  8. 初步了解asp.net运行机制
		
    客户通过客户端浏览器输入url地址请求资源,服务器接收到客户端请求,首先为http请求分配应用程序池,然后在应用程序池中创建请求需要的管道,这个管道对http请求的各个步骤进行了分配. 当用户第一次请 ...
    
		
    9. 
						
  9. ASP.NET运行机制之一般处理程序（ashx）
		
    一. 概述 新建一个ashx文件  代码如下 <%@ WebHandler Language="C#" Class="TestHandler" %> ...
    
		
    10. 
		

	


随机推荐
	

    
									
  1. 在Mac OS X上安装Ionic
			
    安装xcode(从app store下载,用于编译调试ios平台app) 安装node.js(npm) 安装ionic(sudo npm install -g ionic) 安装cordova(sud ...
    
			
    2. 
						
  2. #316 div.2
			
    主要记录下被坑的B.果然大晚上脑子就是不知道在干嘛,明明都测到 “1 1” 这个样例错了都没发现直接给放过去了,白白让人hack爽了... 题意就是给你一个数m,让你从1~n个数中选一个作a,使1~n ...
    
			
    3. 
						
  3. nodejs5-package.json
			
    name:包名,唯一,由小写字符.数字和下划线组成,不能有空格 preferglobal:是否支持全局安装,true表示支持 descrition:描述 version:版本号 author:作者信息 ...
    
			
    4. 
						
  4. MDNavBarView下拉导航菜单（仿美团导航下拉菜单）
			
    说到下拉导航菜单这个东西用得还真不少,细心算一下做开发以来这样的菜单已经写了第三次了,但基本都是不能复用.感觉特累人.不经意看到同事写一个类似的下拉菜单,但他引用了开源库仿大众菜单的库,大致看了一下, ...
    
			
    5. 
						
  5. 运维人愿意听到的话 vs 不愿意听到的话
			
    在公司兼做了接近两年的远程运维工作,与内部打交道的过程中听到各种各样的话, 简单摘列一下那些似曾相识的愿意.不愿意听到的话: ”先别操作,帮忙先拷贝日志!我们调查一下答复!“  vs  ”你先重启一下 ...
    
			
    6. 
						
  6. 转：C#写的WEB服务器
			
    转:http://www.cnblogs.com/x369/articles/79245.html 这只是一个简单的用C#写的WEB服务器,只实现了get方式的对html文件的请求,有兴趣的朋友可以在 ...
    
			
    7. 
						
  7. 苹果系统开发中的混合编程(1):Objective-C和C++的相互调用
			
    首先是OC调用C++的代码.   创建一个Objective-C的项目,并创建c++文件MyCppFile.hpp和MyCppFile.cpp.   把要调用Cpp代码的文件名改成mm后缀名,项目代码 ...
    
			
    8. 
						
  8. 20101102--SQL字符串函数 ，日期和时间函数
			
    --------------------字符串函数------------------------- --ASCII 返回字符串的首字母的ASCII编码 select ASCII('w') selec ...
    
			
    9. 
						
  9. UI3_UITableViewDelete(多选)
			
    // AppDelegate.m // UI3_UITableViewDelete(多选) // // Created by zhangxueming on 15/7/14. // Copyright ...
    
			
    10. 
						
  10. (转)Linux vmstat命令实战详解
			
    vmstat命令是最常见的Linux/Unix监控工具,可以展现给定时间间隔的服务器的状态值,包括服务器的CPU使用率,内存使用,虚拟内存交换情况,IO读写情况.这个命令是我查看Linux/Unix最 ...
    
			
    11.