ASP.NET Page Life Cycle

I am writing this blog because one of my friends asked me to write on this very important phase of programming. This is very hot question asked during interview.

Here I am explaining all the phases of ASP.NET page life cycle step by step and I also tried to show what happen in every phase of page life cycle.

Page_Init Page Initialization
LoadViewState View State Loading
LoadPostData Postback Data Processing
Page_Load Page Loading
RaisePostDataChangedEvent PostBack Change Notification
RaisePostBackEvent PostBack Event Handling
Page_PreRender Page Pre Rendering Phase
SaveViewState View State Saving
Page_Render Page Rendering
Page_Unload Page Unloading

Now see what happen in real life

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Web;  
  5. using System.Web.UI;  
  6. using System.Web.UI.WebControls;  
  7. namespace WebApplication1   
  8. {  
  9.     public partial class _Default: Page   
  10.     {  
  11.         protected void Page_PreInit(object sender, EventArgs e) {  
  12.             //Check the IsPostBack property to determine whether this is the first time the page is being processed.  
  13.             //Create or re-create dynamic controls.  
  14.             //Set a master page dynamically.  
  15.             //Set the Theme property dynamically.  
  16.             //Read or set profile property values.  
  17.         }  
  18.         protected void Page_Init(object sender, EventArgs e) {  
  19.             //Raised after all controls have been initialized and any skin settings have been applied.   
  20.             //Use this event to read or initialize control properties.  
  21.         }  
  22.         protected void Page_InitComplete(object sender, EventArgs e) {  
  23.             //Raised by the Page object. Use this event for processing tasks that require all initialization be complete.  
  24.         }  
  25.         protected void Page_Preload(object sender, EventArgs e) {  
  26.             //Use this event if you need to perform processing on your page or control before the Load event.  
  27.             /*After the Page raises this event, it loads view state for itself and all controls, 
  28. and then processes any postback data included with the Request instance. */  
  29.         }  
  30.         protected void Page_Load(object sender, EventArgs e) {  
  31.             /* The Page calls the OnLoad event method on the Page,  
  32. then recursively does the same for each child control,  
  33. which does the same for each of its child controls  
  34. until the page and all controls are loaded. */  
  36.             //Use the OnLoad event method to set properties in controls and establish database connections.  
  37.         }  
  38.         protected void Page_LoadComplete(object sender, EventArgs e) {  
  39.             //Use this event for tasks that require that all other controls on the page be loaded.  
  40.         }  
  41.         protected void Page_PreRender(object sender, EventArgs e) {  
  42.             /* Raised after the Page object has created all controls that are  
  43. required in order to render the page, including child controls of composite controls. 
  44. The Page object raises the PreRender event on the Page object,  
  45. and then recursively does the same for each child control.  
  46. The PreRender event of individual controls occurs after the PreRender event of the page. 
  47. The PreRender event of individual controls occurs after the PreRender event of the page. 
  48. Allows final changes to the page or its control. 
  49. This event takes place before saving ViewState, so any changes made here are saved.  
  50. */  
  51.         }  
  52.         protected override void OnSaveStateComplete(EventArgs e) {  
  53.             /* Before this event occurs, ViewState has been saved for the page and for all controls.  
  54. Any changes to the page or controls at this point will be ignored.  
  55. Use this event perform tasks that require view state to be saved,  
  56. but that do not make any changes to controls. */  
  57.         }  
  58.         /* Now Here is Render: This is a method of the page object and its controls (and not an event).  
  59. At this point, ASP.NET calls this method on each of the page’s controls to get its output. 
  60. The Render method generates the client-side HTML, Dynamic Hypertext Markup Language (DHTML),  
  61. and script that are necessary to properly display a control at the browser. */  
  62.         protected void Page_UnLoad(object sender, EventArgs e) {  
  63.             /* This event occurs for each control and then for the page.  
  64. In controls, use this event to do final cleanup for specific controls,  
  65. such as closing control-specific database connections.  
  66. During the unload stage, the page and its controls have been rendered,  
  67. so you cannot make further changes to the response stream.  
  68. If you attempt to call a method such as the Response.Write method, the page will throw an exception. */  
  69.         }  
  70.     }  
  71. }