What are application page life cycle events?

In ASP.NET, the page life cycle events are methods that you can override in your page's code-behind file to execute custom logic at specific stages of the page life cycle. Here are all the application page life cycle events and examples of how they can be implemented:

Page_PreInit: This event is an important event in the ASP.NET page life cycle that occurs before the initialization stage. It allows you to perform any necessary tasks before the initialization of the page and its controls. Here's an example of how to use the Page_PreInit event:

protected void Page_PreInit(object sender, EventArgs e)
{
    // Custom logic before page initialization
    // This event can be used to modify the page's master page, theme, or dynamically set the page's master page.
    // It is typically used to apply a different master page dynamically based on certain conditions.

    // Example: Dynamically setting the master page
    if (someCondition)
    {
        this.MasterPageFile = "~/CustomMasterPage.master";
    }
    else
    {
        this.MasterPageFile = "~/DefaultMasterPage.master";
    }
}

In the above example, the Page_PreInit event is used to dynamically set the master page based on a condition. Depending on the condition, a different master page is applied to the page.

Page_Init: This event occurs during the initialization stage of the page life cycle. It is the first opportunity to initialize the page and its controls.

protected void Page_Init(object sender, EventArgs e)
{
    // Custom initialization logic
    // This event is typically used to dynamically create controls or set control properties.
}

Page_InitComplete: This event occurs when the initialization stage of the page life cycle is complete. It allows you to perform any additional initialization tasks after the controls have been initialized.

protected void Page_InitComplete(object sender, EventArgs e)
{
    // Custom logic after the initialization stage is complete
    // This event can be used for additional control setup or initialization.
}

Page_PreLoad: This event occurs just before the page is loaded. It is commonly used for tasks that need to be executed before the page's view state is loaded and postback data is processed.

protected void Page_PreLoad(object sender, EventArgs e)
{
    // Custom logic before the page is loaded
    // This event is useful for preloading data or performing tasks before view state and postback data are processed.
}

Page_Load: This event occurs after the initialization stage and is commonly used to populate controls with data or perform other tasks that need to be executed on each page load.

protected void Page_Load(object sender, EventArgs e)
{
    // Custom logic to load data and perform tasks
    // This event is commonly used for data binding and setting control values.
}

Page_LoadComplete: This event occurs at the end of the page load stage. It allows you to perform any additional tasks after the page and its controls have been loaded.

protected void Page_LoadComplete(object sender, EventArgs e)
{
    // Custom logic after the page and its controls have been loaded
    // This event can be used for additional tasks that need to be executed after the page is fully loaded.
}

Page_PreRender: This event occurs just before the rendering stage and allows you to make final modifications to the page or controls.

protected void Page_PreRender(object sender, EventArgs e)
{
    // Custom logic to modify controls or perform calculations
    // This event is useful for applying final changes to control properties.
}

Page_PreRenderComplete: This event occurs after the PreRender stage is complete. It allows you to perform any additional tasks before the page is rendered.

protected void Page_PreRenderComplete(object sender, EventArgs e)
{
    // Custom logic after the PreRender stage is complete
    // This event can be used for additional tasks that need to be executed before the page is rendered.
}

Page_SaveStateComplete: This event occurs after the view state and control state of the page and its controls have been saved. It allows you to perform any additional tasks after the state has been saved.

protected void Page_SaveStateComplete(object sender, EventArgs e)
{
    // Custom logic after the view state and control state have been saved
    // This event can be used for additional tasks that need to be executed after the state has been saved.
}

Page_Render: This event occurs during the rendering stage. It is primarily used for rendering the HTML markup of the page and itscontrols.

protected override void Render(HtmlTextWriter writer)
{
    // Custom rendering logic
    // This event is typically overridden to customize the rendering of the page or controls.
    // You can modify the HTML output or inject additional markup.
}

Page_Unload: This event occurs after the page has been fully rendered and sent to the client. It is the last chance to perform any cleanup or release resources associated with the page.

protected void Page_Unload(object sender, EventArgs e)
{
    // Custom cleanup logic or releasing resources
    // This event is typically used to dispose of objects or perform final cleanup.
}

To use these events, you need to define the event handlers in your page's code-behind file and override the respective methods. For example:

public partial class MyPage : System.Web.UI.Page
{
    protected void Page_PreInit(object sender, EventArgs e)
    {
	  // Custom logic before page initialization
	  // This event can be used to modify the page's master page, theme, or dynamically set the page's master page.
	  // It is typically used to apply a different master page dynamically based on certain conditions.

	  // Example: Dynamically setting the master page
	  if (someCondition)
	  {
		 this.MasterPageFile = "~/CustomMasterPage.master";
	  }
	  else
	  {
		 this.MasterPageFile = "~/DefaultMasterPage.master";
	  }
    }
	
    protected void Page_Init(object sender, EventArgs e)
    {
        // Custom initialization logic
    }

    protected void Page_InitComplete(object sender, EventArgs e)
    {
        // Custom logic after the initialization stage is complete
    }

    protected void Page_PreLoad(object sender, EventArgs e)
    {
        // Custom logic before the page is loaded
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        // Custom logic to load data and perform tasks
    }

    protected void Page_LoadComplete(object sender, EventArgs e)
    {
        // Custom logic after the page and its controls have been loaded
    }

    protected void Page_PreRender(object sender, EventArgs e)
    {
        // Custom logic to modify controls or perform calculations
    }

    protected void Page_PreRenderComplete(object sender, EventArgs e)
    {
        // Custom logic after the PreRender stage is complete
    }

    protected void Page_SaveStateComplete(object sender, EventArgs e)
    {
        // Custom logic after the view state and control state have been saved
    }

    protected override void Render(HtmlTextWriter writer)
    {
        // Custom rendering logic
    }

    protected void Page_Unload(object sender, EventArgs e)
    {
        // Custom cleanup logic or releasing resources
    }
}

By overriding these events and adding your custom logic, you can control and modify the behavior of your ASP.NET application at each stage of the page life cycle.