【深刻ASP.NET原理系列】--ASP.NET頁面生命週期

時間 2019-11-24

標籤深刻ASP.NET原理系列 asp.net asp 頁面生命週期欄目 ASP 简体版

原文原文鏈接

前言

ASP.NET頁面運行時候，頁面將經歷一個生命週期，在生命週期中將執行一系列的處理步驟。包括初始化、實例化控件、還原和維護狀態、運行時間處理程序代碼以及進行呈現。熟悉頁面生命週期很是重要，這樣咱們才能在生命週期的合適階段編寫代碼。若是咱們能在寫代碼的時候想着咱們如今是在作生命週期的哪一步那將是很是好的。html

你可能會說我不清楚還不是同樣寫代碼，反正每次都在Page_load裏面寫代碼而後頁面就出來了我管那麼多幹什麼。所謂知其然若是能知其因此然豈不是更吊？我我的認爲作ASP.NET B/S WebForm開發只要我們熟悉ASP.NET頁面生命週期，熟悉「請求-處理-響應「模式，對於一時半兒沒有觸及到的細節，等真正遇到那個點再去理解它也是絕不費力的。web

幾個表明性的問題

在開始的時候咱們先思考幾個問題，看看咱們在描述完頁面生命週期的時候，能不能回答上這幾個問題瀏覽器

1.爲何在服務器端能經過this.textbox1.Text獲取到用戶提交過來的數據？服務器

2.在Page_Load中Response.Write("hello")查看生成的html代碼原文件，hello在哪裏？爲何？ide

3.有一個服務器端的按鈕，設置了點擊事件，該點擊事件何時執行？是先執行Page_Load事件仍是先執行點擊事件？工具

4.爲何在服務器端經過this.textbox1.Text設置值後，客戶端就能顯示出來？post

看過我上一篇博客【深刻ASP.NET原理系列】--ASP.NET請求管道、應用程序生命週期、總體運行機制童鞋可能知道，ASP.NET應用程序週期中PreRequestHandlerExecute事件與PostRequestHandlerExecute事件之間就是咱們的頁面生命週期了，對於aspx頁面就是一系列的打造頁面控件樹，觸發各類頁面時間，對於通常處理程序ashx就是直接執行我們開發者寫的ProcessRequest方法了，對於MVC應用程序就是建立控制器工廠，建立控制器對象，調用Action那一套了。學習

下面主要講述的就是ASP.NET WebForm中的頁面的生命週期了。ui

咱們用反編譯工具查看Page類的ProcessRequest方法能夠看見先調用了FrameworkInitialize; FrameworkInitialize裏面就是打造了頁面控件樹，而後調用了ProcessRequestMain，就開始了執行整個頁面生命週期了（其實就是調用了一系列的事件方法）（可能部分圖看不見右邊，可在新標籤頁中打開圖片）this

1.打造頁面控件樹

FrameworkInitialize內部調用了_buildControlTree（）方法

　　

上圖中左邊是前臺頁面的代碼，右邊是對應 生成的打造控件樹的代碼。中間截取的是生成表單那一部分的代碼。

下面看一張原理圖

瀏覽器的DOM樹是根據Html標籤生成一個C語言的DOM樹，而ASP.NET服務器端是用C#打造的一個控件樹，也是按照DOM結構打造的。本質是同樣。服務器端全部東西都加到頁面對象的控件集合中去了。標籤在服務器端有對應的控件對象的時候就用控件對象，沒有的時候就使用LiteralControl進行封裝。不論是服務器控件仍是字符串標籤（沒有runat="server"的標籤）都以控件對象的方式存在前臺頁面類的控件集合裏面。好處就是生成前臺頁面的html代碼的時候，只須要遍歷控件集合裏面的每個控件對象的RenderControl方法，每個控件都會調用本身的Render方法生成對應的Html字符串。那麼全部控件的生成的html字符串就還原成一個頁面的html代碼了。

2.觸發PerformPreInit事件　

在全部初始化以前初始化了這個事件，這個事件主要是初始化了主題，初始化了母版頁

 1 private void PerformPreInit()
 2 
 3 {
 4 
 5     this.OnPreInit(EventArgs.Empty);
 6 
 7     this.InitializeThemes();
 8 
 9     this.ApplyMasterPage();
10 
11     this._preInitWorkComplete = true;
12 
13 }

View Code

3.觸發InitRecursive事件

4.觸發LoadAllState()事件

加載頁面狀態解析ViewState，將頁面表單中的ViewState進行反Base64編碼，反序列化，存在頁面的ViewState屬性中

5.觸發ProcessPostData(this._requestValueCollection, true)事件

 1 private void ProcessPostData(NameValueCollection postData, bool fBeforeLoad)
 2 {
 3     if (this._changedPostDataConsumers == null)
 4     {
 5         this._changedPostDataConsumers = new ArrayList();
 6     }
 7     if (postData != null)
 8     {
 9         foreach (string str in postData)
10         {
11             if ((str != null) && !IsSystemPostField(str))
12             {
13                 Control control = this.FindControl(str);
14                 if (control == null)
15                 {
16                     if (fBeforeLoad)
17                     {
18                         if (this._leftoverPostData == null)
19                         {
20                             this._leftoverPostData = new NameValueCollection();
21                         }
22                         this._leftoverPostData.Add(str, null);
23                     }
24                 }
25                 else
26                 {
27                     IPostBackDataHandler postBackDataHandler = control.PostBackDataHandler;
28                     if (postBackDataHandler == null)
29                     {
30                         if (control.PostBackEventHandler != null)
31                         {
32                             this.RegisterRequiresRaiseEvent(control.PostBackEventHandler);
33                         }
34                     }
35                     else
36                     {
37                         if (postBackDataHandler != null)
38                         {
39                             NameValueCollection postCollection = control.CalculateEffectiveValidateRequest() ? this._requestValueCollection : this._unvalidatedRequestValueCollection;
40                             if (postBackDataHandler.LoadPostData(str, postCollection))
41                             {
42                                 this._changedPostDataConsumers.Add(control);
43                             }
44                         }
45                         if (this._controlsRequiringPostBack != null)
46                         {
47                             this._controlsRequiringPostBack.Remove(str);
48                         }
49                     }
50                 }
51             }
52         }
53     }
54     ArrayList list = null;
55     if (this._controlsRequiringPostBack != null)
56     {
57         foreach (string str2 in this._controlsRequiringPostBack)
58         {
59             Control control2 = this.FindControl(str2);
60             if (control2 != null)
61             {
62                 IPostBackDataHandler adapterInternal = control2.AdapterInternal as IPostBackDataHandler;
63                 if (adapterInternal == null)
64                 {
65                     adapterInternal = control2 as IPostBackDataHandler;
66                 }
67                 if (adapterInternal == null)
68                 {
69                     object[] args = new object[] { str2 };
70                     throw new HttpException(SR.GetString("Postback_ctrl_not_found", args));
71                 }
72                 NameValueCollection values2 = control2.CalculateEffectiveValidateRequest() ? this._requestValueCollection : this._unvalidatedRequestValueCollection;
73                 if (adapterInternal.LoadPostData(str2, values2))
74                 {
75                     this._changedPostDataConsumers.Add(control2);
76                 }
77             }
78             else if (fBeforeLoad)
79             {
80                 if (list == null)
81                 {
82                     list = new ArrayList();
83                 }
84                 list.Add(str2);
85             }
86         }
87         this._controlsRequiringPostBack = list;
88     }
89 }
90 
91  
92 
93 
94

View Code

主要作了兩件事

1）將表單裏提交過來的控件數據設置給頁面對象的控件樹中對應控件的屬性（給前面打造的控件樹裏面控件給值），這樣在服務器端就能夠拿到客戶端輸入的值了。

2）將表單裏面提交過來的值與ViewState中控件原來的值進行比對，不一樣則表示要觸發該控件的Change 事件，則同時將該控件放到一個集合（看源碼其實就是changedPostDataConsumers）中。在後續執行過程當中遍歷改集合依次觸發對應控件的Change事件。

6.觸發LoadRecursive()事件

大名鼎鼎的Page_Load就是在這裏執行的。不過是先執行頁面自己的Load事件再執行頁面控件的Load事件哦,這時候前面給控件賦的值,表單提交過來的數據,ViewState等等均可以使用了，IsPostBack的原理就是判斷是否有name爲__VIEWSTATE的數據提交過來

7.再次觸發ProcessPostData(this._leftoverPostData, false)事件

這個事件我在網上看了不少人說是將第一次遺漏下來的，第一次執行ProcessPostData沒有涉及到的控件進行處理，可是並無說明哪些遺漏下來了。爲何第一次沒處理了？ 最後Google查到是處理咱們開發者在頁面的Page_Load方法中添加的控件。在Page_Load中咱們能夠本身建立控件對象加到頁面對應的「C#DOM樹中「，如：在Page_Load中寫
TextBox txt = new TextBox();txt.ID ="myTxtBox";this.form1.Controls.Add(txt);
這就是把開發者本身建立的控件加在頁面的form1的表單中。固然你也能夠加上Change事件了建立控件的時候。執行的仍是上面那兩件事了。則回發的時候能夠給開發者在Page_Lod中手動建立的控件還原值。

8.觸發RaiseChangedEvents事件

循環遍歷changedPostDataConsumers集合中的全部控件，依次執行控件的非點擊回傳事件，好比文本框的改變事件等

9.觸發RaisePostBackEvent(this._requestValueCollection)事件

執行按鈕點擊回傳事件或者驗證事件，若是有多個按鈕，根據回發過來的按鈕的 name來判斷觸發哪一個按鈕的事件，或者觸發該控件的驗證事件

10.觸發PerformPreRenderComplete事件

循環遍歷控件樹中全部的控件，根據每一個控件生成對應的Html代碼，把服務器控件渲染成普通的html控件。

11.觸發事件SaveAllState事件

將服務器端ViewState集合中的內容（開發者本身加的數據或控件狀態信息等）序列化而後Base64編碼而後設置到客戶端隱藏域__ViewState中

12.RenderControl(this.CreateHtmlTextWriter(this.Response.Output))

把要發送到客戶端瀏覽器的內容設置到Response.Output，應用程序將它發送 到客戶端瀏覽器。

看到這裏不知道你們是否已經能夠清晰地回答開篇提到的幾個問題了，其實就是這些事件執行的前後順序，頁面生命週期了。」前人植樹，後人乘涼了"

最後附上生命週期ProcessRequest源碼　　

  1 private void ProcessRequestMain(bool includeStagesBeforeAsyncPoint, bool includeStagesAfterAsyncPoint)
  2 {
  3     try
  4     {
  5         HttpContext context = this.Context;
  6         string str = null;
  7         if (includeStagesBeforeAsyncPoint)
  8         {
  9             if (this.IsInAspCompatMode)
 10             {
 11                 AspCompatApplicationStep.OnPageStartSessionObjects();
 12             }
 13             if (this.PageAdapter != null)
 14             {
 15                 this._requestValueCollection = this.PageAdapter.DeterminePostBackMode();
 16                 if (this._requestValueCollection != null)
 17                 {
 18                     this._unvalidatedRequestValueCollection = this.PageAdapter.DeterminePostBackModeUnvalidated();
 19                 }
 20             }
 21             else
 22             {
 23                 this._requestValueCollection = this.DeterminePostBackMode();
 24                 if (this._requestValueCollection != null)
 25                 {
 26                     this._unvalidatedRequestValueCollection = this.DeterminePostBackModeUnvalidated();
 27                 }
 28             }
 29             string callbackControlID = string.Empty;
 30             if (this.DetermineIsExportingWebPart())
 31             {
 32                 if (!RuntimeConfig.GetAppConfig().WebParts.EnableExport)
 33                 {
 34                     throw new InvalidOperationException(SR.GetString("WebPartExportHandler_DisabledExportHandler"));
 35                 }
 36                 str = this.Request.QueryString["webPart"];
 37                 if (string.IsNullOrEmpty(str))
 38                 {
 39                     throw new InvalidOperationException(SR.GetString("WebPartExportHandler_InvalidArgument"));
 40                 }
 41                 if (string.Equals(this.Request.QueryString["scope"], "shared", StringComparison.OrdinalIgnoreCase))
 42                 {
 43                     this._pageFlags.Set(4);
 44                 }
 45                 string str3 = this.Request.QueryString["query"];
 46                 if (str3 == null)
 47                 {
 48                     str3 = string.Empty;
 49                 }
 50                 this.Request.QueryStringText = str3;
 51                 context.Trace.IsEnabled = false;
 52             }
 53             if (this._requestValueCollection != null)
 54             {
 55                 if (this._requestValueCollection["__VIEWSTATEENCRYPTED"] != null)
 56                 {
 57                     this.ContainsEncryptedViewState = true;
 58                 }
 59                 callbackControlID = this._requestValueCollection["__CALLBACKID"];
 60                 if ((callbackControlID != null) && (this._request.HttpVerb == HttpVerb.POST))
 61                 {
 62                     this._isCallback = true;
 63                 }
 64                 else if (!this.IsCrossPagePostBack)
 65                 {
 66                     VirtualPath path = null;
 67                     if (this._requestValueCollection["__PREVIOUSPAGE"] != null)
 68                     {
 69                         try
 70                         {
 71                             path = VirtualPath.CreateNonRelativeAllowNull(DecryptString(this._requestValueCollection["__PREVIOUSPAGE"], Purpose.WebForms_Page_PreviousPageID));
 72                         }
 73                         catch
 74                         {
 75                             this._pageFlags[8] = true;
 76                         }
 77                         if ((path != null) && (path != this.Request.CurrentExecutionFilePathObject))
 78                         {
 79                             this._pageFlags[8] = true;
 80                             this._previousPagePath = path;
 81                         }
 82                     }
 83                 }
 84             }
 85             if (this.MaintainScrollPositionOnPostBack)
 86             {
 87                 this.LoadScrollPosition();
 88             }
 89             if (context.TraceIsEnabled)
 90             {
 91                 this.Trace.Write("aspx.page", "Begin PreInit");
 92             }
 93             if (EtwTrace.IsTraceEnabled(5, 4))
 94             {
 95                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_ENTER, this._context.WorkerRequest);
 96             }
 97             this.PerformPreInit();
 98             if (EtwTrace.IsTraceEnabled(5, 4))
 99             {
100                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_LEAVE, this._context.WorkerRequest);
101             }
102             if (context.TraceIsEnabled)
103             {
104                 this.Trace.Write("aspx.page", "End PreInit");
105             }
106             if (context.TraceIsEnabled)
107             {
108                 this.Trace.Write("aspx.page", "Begin Init");
109             }
110             if (EtwTrace.IsTraceEnabled(5, 4))
111             {
112                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_ENTER, this._context.WorkerRequest);
113             }
114             this.InitRecursive(null);
115             if (EtwTrace.IsTraceEnabled(5, 4))
116             {
117                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_LEAVE, this._context.WorkerRequest);
118             }
119             if (context.TraceIsEnabled)
120             {
121                 this.Trace.Write("aspx.page", "End Init");
122             }
123             if (context.TraceIsEnabled)
124             {
125                 this.Trace.Write("aspx.page", "Begin InitComplete");
126             }
127             this.OnInitComplete(EventArgs.Empty);
128             if (context.TraceIsEnabled)
129             {
130                 this.Trace.Write("aspx.page", "End InitComplete");
131             }
132             if (this.IsPostBack)
133             {
134                 if (context.TraceIsEnabled)
135                 {
136                     this.Trace.Write("aspx.page", "Begin LoadState");
137                 }
138                 if (EtwTrace.IsTraceEnabled(5, 4))
139                 {
140                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_ENTER, this._context.WorkerRequest);
141                 }
142                 this.LoadAllState();
143                 if (EtwTrace.IsTraceEnabled(5, 4))
144                 {
145                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_LEAVE, this._context.WorkerRequest);
146                 }
147                 if (context.TraceIsEnabled)
148                 {
149                     this.Trace.Write("aspx.page", "End LoadState");
150                     this.Trace.Write("aspx.page", "Begin ProcessPostData");
151                 }
152                 if (EtwTrace.IsTraceEnabled(5, 4))
153                 {
154                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_ENTER, this._context.WorkerRequest);
155                 }
156                 this.ProcessPostData(this._requestValueCollection, true);
157                 if (EtwTrace.IsTraceEnabled(5, 4))
158                 {
159                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_LEAVE, this._context.WorkerRequest);
160                 }
161                 if (context.TraceIsEnabled)
162                 {
163                     this.Trace.Write("aspx.page", "End ProcessPostData");
164                 }
165             }
166             if (context.TraceIsEnabled)
167             {
168                 this.Trace.Write("aspx.page", "Begin PreLoad");
169             }
170             this.OnPreLoad(EventArgs.Empty);
171             if (context.TraceIsEnabled)
172             {
173                 this.Trace.Write("aspx.page", "End PreLoad");
174             }
175             if (context.TraceIsEnabled)
176             {
177                 this.Trace.Write("aspx.page", "Begin Load");
178             }
179             if (EtwTrace.IsTraceEnabled(5, 4))
180             {
181                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_ENTER, this._context.WorkerRequest);
182             }
183             this.LoadRecursive();
184             if (EtwTrace.IsTraceEnabled(5, 4))
185             {
186                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_LEAVE, this._context.WorkerRequest);
187             }
188             if (context.TraceIsEnabled)
189             {
190                 this.Trace.Write("aspx.page", "End Load");
191             }
192             if (this.IsPostBack)
193             {
194                 if (context.TraceIsEnabled)
195                 {
196                     this.Trace.Write("aspx.page", "Begin ProcessPostData Second Try");
197                 }
198                 this.ProcessPostData(this._leftoverPostData, false);
199                 if (context.TraceIsEnabled)
200                 {
201                     this.Trace.Write("aspx.page", "End ProcessPostData Second Try");
202                     this.Trace.Write("aspx.page", "Begin Raise ChangedEvents");
203                 }
204                 if (EtwTrace.IsTraceEnabled(5, 4))
205                 {
206                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_ENTER, this._context.WorkerRequest);
207                 }
208                 this.RaiseChangedEvents();
209                 if (EtwTrace.IsTraceEnabled(5, 4))
210                 {
211                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_LEAVE, this._context.WorkerRequest);
212                 }
213                 if (context.TraceIsEnabled)
214                 {
215                     this.Trace.Write("aspx.page", "End Raise ChangedEvents");
216                     this.Trace.Write("aspx.page", "Begin Raise PostBackEvent");
217                 }
218                 if (EtwTrace.IsTraceEnabled(5, 4))
219                 {
220                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_ENTER, this._context.WorkerRequest);
221                 }
222                 this.RaisePostBackEvent(this._requestValueCollection);
223                 if (EtwTrace.IsTraceEnabled(5, 4))
224                 {
225                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_LEAVE, this._context.WorkerRequest);
226                 }
227                 if (context.TraceIsEnabled)
228                 {
229                     this.Trace.Write("aspx.page", "End Raise PostBackEvent");
230                 }
231             }
232             if (context.TraceIsEnabled)
233             {
234                 this.Trace.Write("aspx.page", "Begin LoadComplete");
235             }
236             this.OnLoadComplete(EventArgs.Empty);
237             if (context.TraceIsEnabled)
238             {
239                 this.Trace.Write("aspx.page", "End LoadComplete");
240             }
241             if (this.IsPostBack && this.IsCallback)
242             {
243                 this.PrepareCallback(callbackControlID);
244             }
245             else if (!this.IsCrossPagePostBack)
246             {
247                 if (context.TraceIsEnabled)
248                 {
249                     this.Trace.Write("aspx.page", "Begin PreRender");
250                 }
251                 if (EtwTrace.IsTraceEnabled(5, 4))
252                 {
253                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_ENTER, this._context.WorkerRequest);
254                 }
255                 this.PreRenderRecursiveInternal();
256                 if (EtwTrace.IsTraceEnabled(5, 4))
257                 {
258                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_LEAVE, this._context.WorkerRequest);
259                 }
260                 if (context.TraceIsEnabled)
261                 {
262                     this.Trace.Write("aspx.page", "End PreRender");
263                 }
264             }
265         }
266         if ((this._legacyAsyncInfo == null) || this._legacyAsyncInfo.CallerIsBlocking)
267         {
268             this.ExecuteRegisteredAsyncTasks();
269         }
270         this.ValidateRawUrlIfRequired();
271         if (includeStagesAfterAsyncPoint)
272         {
273             if (this.IsCallback)
274             {
275                 this.RenderCallback();
276             }
277             else if (!this.IsCrossPagePostBack)
278             {
279                 if (context.TraceIsEnabled)
280                 {
281                     this.Trace.Write("aspx.page", "Begin PreRenderComplete");
282                 }
283                 this.PerformPreRenderComplete();
284                 if (context.TraceIsEnabled)
285                 {
286                     this.Trace.Write("aspx.page", "End PreRenderComplete");
287                 }
288                 if (context.TraceIsEnabled)
289                 {
290                     this.BuildPageProfileTree(this.EnableViewState);
291                     this.Trace.Write("aspx.page", "Begin SaveState");
292                 }
293                 if (EtwTrace.IsTraceEnabled(5, 4))
294                 {
295                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_ENTER, this._context.WorkerRequest);
296                 }
297                 this.SaveAllState();
298                 if (EtwTrace.IsTraceEnabled(5, 4))
299                 {
300                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_LEAVE, this._context.WorkerRequest);
301                 }
302                 if (context.TraceIsEnabled)
303                 {
304                     this.Trace.Write("aspx.page", "End SaveState");
305                     this.Trace.Write("aspx.page", "Begin SaveStateComplete");
306                 }
307                 this.OnSaveStateComplete(EventArgs.Empty);
308                 if (context.TraceIsEnabled)
309                 {
310                     this.Trace.Write("aspx.page", "End SaveStateComplete");
311                     this.Trace.Write("aspx.page", "Begin Render");
312                 }
313                 if (EtwTrace.IsTraceEnabled(5, 4))
314                 {
315                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_ENTER, this._context.WorkerRequest);
316                 }
317                 if (str != null)
318                 {
319                     this.ExportWebPart(str);
320                 }
321                 else
322                 {
323                     this.RenderControl(this.CreateHtmlTextWriter(this.Response.Output));
324                 }
325                 if (EtwTrace.IsTraceEnabled(5, 4))
326                 {
327                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_LEAVE, this._context.WorkerRequest);
328                 }
329                 if (context.TraceIsEnabled)
330                 {
331                     this.Trace.Write("aspx.page", "End Render");
332                 }
333                 this.CheckRemainingAsyncTasks(false);
334             }
335         }
336     }
337     catch (ThreadAbortException exception1)
338     {
339         HttpApplication.CancelModuleException exceptionState = exception1.ExceptionState as HttpApplication.CancelModuleException;
340         if ((((includeStagesBeforeAsyncPoint & includeStagesAfterAsyncPoint) && (this._context.Handler == this)) && ((this._context.ApplicationInstance != null) && (exceptionState != null))) && !exceptionState.Timeout)
341         {
342             this._context.ApplicationInstance.CompleteRequest();
343             ThreadResetAbortWithAssert();
344         }
345         else
346         {
347             this.CheckRemainingAsyncTasks(true);
348             throw;
349         }
350     }
351     catch (ConfigurationException)
352     {
353         throw;
354     }
355     catch (Exception exception2)
356     {
357         PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_DURING_REQUEST);
358         PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);
359         if (!this.HandleError(exception2))
360         {
361             throw;
362         }
363     }
364 }
365 
366  
367 
368  
369   private void ProcessRequestMain(bool includeStagesBeforeAsyncPoint, bool includeStagesAfterAsyncPoint)
370 {
371     try
372     {
373         HttpContext context = this.Context;
374         string str = null;
375         if (includeStagesBeforeAsyncPoint)
376         {
377             if (this.IsInAspCompatMode)
378             {
379                 AspCompatApplicationStep.OnPageStartSessionObjects();
380             }
381             if (this.PageAdapter != null)
382             {
383                 this._requestValueCollection = this.PageAdapter.DeterminePostBackMode();
384                 if (this._requestValueCollection != null)
385                 {
386                     this._unvalidatedRequestValueCollection = this.PageAdapter.DeterminePostBackModeUnvalidated();
387                 }
388             }
389             else
390             {
391                 this._requestValueCollection = this.DeterminePostBackMode();
392                 if (this._requestValueCollection != null)
393                 {
394                     this._unvalidatedRequestValueCollection = this.DeterminePostBackModeUnvalidated();
395                 }
396             }
397             string callbackControlID = string.Empty;
398             if (this.DetermineIsExportingWebPart())
399             {
400                 if (!RuntimeConfig.GetAppConfig().WebParts.EnableExport)
401                 {
402                     throw new InvalidOperationException(SR.GetString("WebPartExportHandler_DisabledExportHandler"));
403                 }
404                 str = this.Request.QueryString["webPart"];
405                 if (string.IsNullOrEmpty(str))
406                 {
407                     throw new InvalidOperationException(SR.GetString("WebPartExportHandler_InvalidArgument"));
408                 }
409                 if (string.Equals(this.Request.QueryString["scope"], "shared", StringComparison.OrdinalIgnoreCase))
410                 {
411                     this._pageFlags.Set(4);
412                 }
413                 string str3 = this.Request.QueryString["query"];
414                 if (str3 == null)
415                 {
416                     str3 = string.Empty;
417                 }
418                 this.Request.QueryStringText = str3;
419                 context.Trace.IsEnabled = false;
420             }
421             if (this._requestValueCollection != null)
422             {
423                 if (this._requestValueCollection["__VIEWSTATEENCRYPTED"] != null)
424                 {
425                     this.ContainsEncryptedViewState = true;
426                 }
427                 callbackControlID = this._requestValueCollection["__CALLBACKID"];
428                 if ((callbackControlID != null) && (this._request.HttpVerb == HttpVerb.POST))
429                 {
430                     this._isCallback = true;
431                 }
432                 else if (!this.IsCrossPagePostBack)
433                 {
434                     VirtualPath path = null;
435                     if (this._requestValueCollection["__PREVIOUSPAGE"] != null)
436                     {
437                         try
438                         {
439                             path = VirtualPath.CreateNonRelativeAllowNull(DecryptString(this._requestValueCollection["__PREVIOUSPAGE"], Purpose.WebForms_Page_PreviousPageID));
440                         }
441                         catch
442                         {
443                             this._pageFlags[8] = true;
444                         }
445                         if ((path != null) && (path != this.Request.CurrentExecutionFilePathObject))
446                         {
447                             this._pageFlags[8] = true;
448                             this._previousPagePath = path;
449                         }
450                     }
451                 }
452             }
453             if (this.MaintainScrollPositionOnPostBack)
454             {
455                 this.LoadScrollPosition();
456             }
457             if (context.TraceIsEnabled)
458             {
459                 this.Trace.Write("aspx.page", "Begin PreInit");
460             }
461             if (EtwTrace.IsTraceEnabled(5, 4))
462             {
463                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_ENTER, this._context.WorkerRequest);
464             }
465             this.PerformPreInit();
466             if (EtwTrace.IsTraceEnabled(5, 4))
467             {
468                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_LEAVE, this._context.WorkerRequest);
469             }
470             if (context.TraceIsEnabled)
471             {
472                 this.Trace.Write("aspx.page", "End PreInit");
473             }
474             if (context.TraceIsEnabled)
475             {
476                 this.Trace.Write("aspx.page", "Begin Init");
477             }
478             if (EtwTrace.IsTraceEnabled(5, 4))
479             {
480                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_ENTER, this._context.WorkerRequest);
481             }
482             this.InitRecursive(null);
483             if (EtwTrace.IsTraceEnabled(5, 4))
484             {
485                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_LEAVE, this._context.WorkerRequest);
486             }
487             if (context.TraceIsEnabled)
488             {
489                 this.Trace.Write("aspx.page", "End Init");
490             }
491             if (context.TraceIsEnabled)
492             {
493                 this.Trace.Write("aspx.page", "Begin InitComplete");
494             }
495             this.OnInitComplete(EventArgs.Empty);
496             if (context.TraceIsEnabled)
497             {
498                 this.Trace.Write("aspx.page", "End InitComplete");
499             }
500             if (this.IsPostBack)
501             {
502                 if (context.TraceIsEnabled)
503                 {
504                     this.Trace.Write("aspx.page", "Begin LoadState");
505                 }
506                 if (EtwTrace.IsTraceEnabled(5, 4))
507                 {
508                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_ENTER, this._context.WorkerRequest);
509                 }
510                 this.LoadAllState();
511                 if (EtwTrace.IsTraceEnabled(5, 4))
512                 {
513                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_LEAVE, this._context.WorkerRequest);
514                 }
515                 if (context.TraceIsEnabled)
516                 {
517                     this.Trace.Write("aspx.page", "End LoadState");
518                     this.Trace.Write("aspx.page", "Begin ProcessPostData");
519                 }
520                 if (EtwTrace.IsTraceEnabled(5, 4))
521                 {
522                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_ENTER, this._context.WorkerRequest);
523                 }
524                 this.ProcessPostData(this._requestValueCollection, true);
525                 if (EtwTrace.IsTraceEnabled(5, 4))
526                 {
527                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_LEAVE, this._context.WorkerRequest);
528                 }
529                 if (context.TraceIsEnabled)
530                 {
531                     this.Trace.Write("aspx.page", "End ProcessPostData");
532                 }
533             }
534             if (context.TraceIsEnabled)
535             {
536                 this.Trace.Write("aspx.page", "Begin PreLoad");
537             }
538             this.OnPreLoad(EventArgs.Empty);
539             if (context.TraceIsEnabled)
540             {
541                 this.Trace.Write("aspx.page", "End PreLoad");
542             }
543             if (context.TraceIsEnabled)
544             {
545                 this.Trace.Write("aspx.page", "Begin Load");
546             }
547             if (EtwTrace.IsTraceEnabled(5, 4))
548             {
549                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_ENTER, this._context.WorkerRequest);
550             }
551             this.LoadRecursive();
552             if (EtwTrace.IsTraceEnabled(5, 4))
553             {
554                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_LEAVE, this._context.WorkerRequest);
555             }
556             if (context.TraceIsEnabled)
557             {
558                 this.Trace.Write("aspx.page", "End Load");
559             }
560             if (this.IsPostBack)
561             {
562                 if (context.TraceIsEnabled)
563                 {
564                     this.Trace.Write("aspx.page", "Begin ProcessPostData Second Try");
565                 }
566                 this.ProcessPostData(this._leftoverPostData, false);
567                 if (context.TraceIsEnabled)
568                 {
569                     this.Trace.Write("aspx.page", "End ProcessPostData Second Try");
570                     this.Trace.Write("aspx.page", "Begin Raise ChangedEvents");
571                 }
572                 if (EtwTrace.IsTraceEnabled(5, 4))
573                 {
574                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_ENTER, this._context.WorkerRequest);
575                 }
576                 this.RaiseChangedEvents();
577                 if (EtwTrace.IsTraceEnabled(5, 4))
578                 {
579                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_LEAVE, this._context.WorkerRequest);
580                 }
581                 if (context.TraceIsEnabled)
582                 {
583                     this.Trace.Write("aspx.page", "End Raise ChangedEvents");
584                     this.Trace.Write("aspx.page", "Begin Raise PostBackEvent");
585                 }
586                 if (EtwTrace.IsTraceEnabled(5, 4))
587                 {
588                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_ENTER, this._context.WorkerRequest);
589                 }
590                 this.RaisePostBackEvent(this._requestValueCollection);
591                 if (EtwTrace.IsTraceEnabled(5, 4))
592                 {
593                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_LEAVE, this._context.WorkerRequest);
594                 }
595                 if (context.TraceIsEnabled)
596                 {
597                     this.Trace.Write("aspx.page", "End Raise PostBackEvent");
598                 }
599             }
600             if (context.TraceIsEnabled)
601             {
602                 this.Trace.Write("aspx.page", "Begin LoadComplete");
603             }
604             this.OnLoadComplete(EventArgs.Empty);
605             if (context.TraceIsEnabled)
606             {
607                 this.Trace.Write("aspx.page", "End LoadComplete");
608             }
609             if (this.IsPostBack && this.IsCallback)
610             {
611                 this.PrepareCallback(callbackControlID);
612             }
613             else if (!this.IsCrossPagePostBack)
614             {
615                 if (context.TraceIsEnabled)
616                 {
617                     this.Trace.Write("aspx.page", "Begin PreRender");
618                 }
619                 if (EtwTrace.IsTraceEnabled(5, 4))
620                 {
621                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_ENTER, this._context.WorkerRequest);
622                 }
623                 this.PreRenderRecursiveInternal();
624                 if (EtwTrace.IsTraceEnabled(5, 4))
625                 {
626                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_LEAVE, this._context.WorkerRequest);
627                 }
628                 if (context.TraceIsEnabled)
629                 {
630                     this.Trace.Write("aspx.page", "End PreRender");
631                 }
632             }
633         }
634         if ((this._legacyAsyncInfo == null) || this._legacyAsyncInfo.CallerIsBlocking)
635         {
636             this.ExecuteRegisteredAsyncTasks();
637         }
638         this.ValidateRawUrlIfRequired();
639         if (includeStagesAfterAsyncPoint)
640         {
641             if (this.IsCallback)
642             {
643                 this.RenderCallback();
644             }
645             else if (!this.IsCrossPagePostBack)
646             {
647                 if (context.TraceIsEnabled)
648                 {
649                     this.Trace.Write("aspx.page", "Begin PreRenderComplete");
650                 }
651                 this.PerformPreRenderComplete();
652                 if (context.TraceIsEnabled)
653                 {
654                     this.Trace.Write("aspx.page", "End PreRenderComplete");
655                 }
656                 if (context.TraceIsEnabled)
657                 {
658                     this.BuildPageProfileTree(this.EnableViewState);
659                     this.Trace.Write("aspx.page", "Begin SaveState");
660                 }
661                 if (EtwTrace.IsTraceEnabled(5, 4))
662                 {
663                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_ENTER, this._context.WorkerRequest);
664                 }
665                 this.SaveAllState();
666                 if (EtwTrace.IsTraceEnabled(5, 4))
667                 {
668                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_LEAVE, this._context.WorkerRequest);
669                 }
670                 if (context.TraceIsEnabled)
671                 {
672                     this.Trace.Write("aspx.page", "End SaveState");
673                     this.Trace.Write("aspx.page", "Begin SaveStateComplete");
674                 }
675                 this.OnSaveStateComplete(EventArgs.Empty);
676                 if (context.TraceIsEnabled)
677                 {
678                     this.Trace.Write("aspx.page", "End SaveStateComplete");
679                     this.Trace.Write("aspx.page", "Begin Render");
680                 }
681                 if (EtwTrace.IsTraceEnabled(5, 4))
682                 {
683                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_ENTER, this._context.WorkerRequest);
684                 }
685                 if (str != null)
686                 {
687                     this.ExportWebPart(str);
688                 }
689                 else
690                 {
691                     this.RenderControl(this.CreateHtmlTextWriter(this.Response.Output));
692                 }
693                 if (EtwTrace.IsTraceEnabled(5, 4))
694                 {
695                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_LEAVE, this._context.WorkerRequest);
696                 }
697                 if (context.TraceIsEnabled)
698                 {
699                     this.Trace.Write("aspx.page", "End Render");
700                 }
701                 this.CheckRemainingAsyncTasks(false);
702             }
703         }
704     }
705     catch (ThreadAbortException exception1)
706     {
707         HttpApplication.CancelModuleException exceptionState = exception1.ExceptionState as HttpApplication.CancelModuleException;
708         if ((((includeStagesBeforeAsyncPoint & includeStagesAfterAsyncPoint) && (this._context.Handler == this)) && ((this._context.ApplicationInstance != null) && (exceptionState != null))) && !exceptionState.Timeout)
709         {
710             this._context.ApplicationInstance.CompleteRequest();
711             ThreadResetAbortWithAssert();
712         }
713         else
714         {
715             this.CheckRemainingAsyncTasks(true);
716             throw;
717         }
718     }
719     catch (ConfigurationException)
720     {
721         throw;
722     }
723     catch (Exception exception2)
724     {
725         PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_DURING_REQUEST);
726         PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);
727         if (!this.HandleError(exception2))
728         {
729             throw;
730         }
731     }
732 }
733 
734