Page life cycle...

All of the events, in order in which they are fired!
	
using System;
...

namespace myNameSpace
{
    public partial class MyClass : System.Web.UI.Page
    {

        protected void Page_PreInt(object sender, EventArgs e)
        {
            /* Use this event for the following:
                  Check the IsPostBack property to determine whether this is the first time the page is being processed.
                  Create or re-create dynamic controls.
                  Set a master page dynamically.
                  Set the Theme property dynamically.
                  Read or set profile property values.
            */ 
        }
        
        protected void Page_Init(Object sender, EventArgs e)
        {
            /*
               Raised after all controls have been initialized and any skin settings have been applied. 
               Use this event to read or initialize control properties. 
            */
            
        }

        protected void Page_InitComplete(Object sender, EventArgs e){
            /*
            Raised by the Page object. Use this event for processing tasks that require all initialization be complete. 
            */
        }

        protected void Page_PreLoad(Object sender, EventArgs e)
        {
            /*
             Use this event if you need to perform processing on your page or control before the Load event.
             
             Before the Page instance raises this event, it loads view state for itself and all controls, 
             and then processes any postback data included with the Request instance.  
            */
            
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            /*
              The Page calls the OnLoad event method on the Page, then recursively does the same for each child control, 
              which does the same for each of its child controls until the page and all controls are loaded.
              Use the OnLoad event method to set properties in controls and establish database connections. 
            */

        }

        /* at this point, all of the controls are loaded */

        protected void Page_LoadComplete(Object sender, EventArgs e)
        {
            /*
             Use this event for tasks that require that all other controls on the page be loaded. 
            */
        }

        protected void Page_PreRender(Object sender, EventArgs e)
        {
            /*
              Before this event occurs:
                  The Page object calls EnsureChildControls for each control and for the page.
             
                  Each data bound control whose DataSourceID property is set calls its DataBind 
                  method. For more information, see Data Binding Events for Data-Bound Controls later in this topic. 

              The PreRender event occurs for each control on the page. Use the event to make final changes 
              to the contents of the page or its controls. 
            */
        }

        protected void Page_SaveStateComplete(Object sender, EventArgs e)
        {
            /*
               Before this event occurs, ViewState has been saved for the page and for all controls. 
               Any changes to the page or controls at this point will be ignored.
             
               Use this event perform tasks that require view state to be saved, but that do not 
               make any changes to controls. 
            */
        }

        protected void Page_Renderer(Object sender, EventArgs e)
        {
            /*
                Before this event occurs, ViewState has been saved for the page and for all controls. 
                Any changes to the page or controls at this point will be ignored.
             
                Use this event perform tasks that require view state to be saved, but that do not make 
                any changes to controls. 
         */
        }


        protected void Page_Unload(Object sender, EventArgs e)
        {
            /*
                This event occurs for each control and then for the page. In controls, use this event to 
                do final cleanup for specific controls, such as closing control-specific database connections.

                For the page itself, use this event to do final cleanup work, such as closing open files and 
                database connections, or finishing up logging or other request-specific tasks.

                During the unload stage, the page and its controls have been rendered, so you cannot make 
                further changes to the response stream. If you attempt to call a method such as the 
                Response.Write method, the page will throw an exception. 
         */
        }

    }
}


	
more than you wanted to know
*Right now you'll care most about General Page Life-cycle Stages and Life-cycle Events
Example of ViewState["identifier"]

ViewState is data sent through the query string (that huge, ugly post)
-Page specific
-the 'cost' of this is adding to the information sent back and forth (bandwidth)
-blown away when you lose the postback

NOT good for:
Example of Session["identifier"]

Session is data stored on the server
-any type of data
-information is protected and never transmitted to client
-uniquely bound to a specific session (each client is different!)
-perfect for storing information between pages (has application scope), such as a users shopping cart (hint, hint)

Done by: Can be lost by:
Example of Application["identifier"]

Application State:
-any type of data
-data same for ALL clients
-never times out
-generally not used (inefficient, dies when server restarted or domain refreshes itself)