In this
article, we will see the stages of execution of the
ASP.NET Page.
Each request for an .aspx page that hits IIS is handed
over to HTTP Pipeline. HTTP Pipeline is a chain of
managed objects that sequentially process the request
and convert it to plain HTML text content. The start
point of HTTP Pipeline is the HttpRuntime class.
The ASP.NET infrastructure creates each instance of this
class per AppDomain hosted within the worker process.
HttpRuntime class picks up an HttpApplication
object from an internal pool and sets it to work on the
request. It finds out what class has to handle the
request. The association between the resources and
handlers are stored in the configurable file of the
application. In web.config and also in
machine.config you will find these lines in <httpHandlers>
section.If you
run through the following program, it will be much
easier to follow.
<add
verb="*"
path="*.aspx"
type="System.Web.UI.PageHandlerFactory"/>
This extension can be
associated with HandlerClass or HandlerFactory
class. HttpApplication object gets the page
object that implements the IHttpHandler
Interface. The process of generating the output to the
browser is started when the object calls
ProcessRequest method.
Page Life Cycle
Once the HTTP page handler class is fully identified,
the ASP.NET runtime calls the handler's
ProcessRequest to start the process. This
implementation begins by calling the method
FrameworkInitialize(), which builds the control
trees for the page. This is a protected and virtual
member of TemplateControl class, class from which
page itself derives.
Next the processRequest() makes page transits
various phases: initialization, loading of viewstate and
postback data, loading of page's user code and execution
postback server-side events. Then page enters in render
mode, the viewstate is updated and HTML generated is
sent to the output console. Finally page is unloaded and
request is considered completely served.
Stages and corresponding events in the life cycle of the
ASP.NET page cycle:
Stage |
Events/Method |
Page Initialization |
Page_Init |
View State Loading |
LoadViewState |
Postback data processing |
LoadPostData |
Page Loading |
Page_Load |
PostBack Change Notification |
RaisePostDataChangedEvent |
PostBack Event Handling |
RaisePostBackEvent |
Page Pre Rendering Phase |
Page_PreRender |
View State Saving |
SaveViewState |
Page Rendering |
Page_Render |
Page Unloading |
Page_UnLoad |
Some of the events listed above are not visible at the
page level. It will be visible if you happen to write
server controls and write a class that is derived from
page.
Page Execution Stages
The first stage in the page life cycle is
initialization. This is fired after the page's
control tree has been successfully created. All the
controls that are statically declared in the .aspx file
will be initialized with the default values. Controls
can use this event to initialize some of the settings
that can be used throughout the lifetime of the incoming
web request. Viewstate information will not be available
at this stage.
After initialization, page framework loads the view
state for the page. Viewstate is a collection of
name/value pairs, where control's and page itself store
information that is persistent among web requests. It
contains the state of the controls the last time the
page was processed on the server. By overriding
LoadViewState() method, component developer can
understand how viewstate is restored.
Once viewstate is
restored, control will be updated with the client side
changes. It loads the posted data values. The
PostBackData event gives control a chance to update
their state that reflects the state of the HTML element
on the client.
At the end of the posted data changes event, controls
will be reflected with changes done on the client. At
this point, load event is fired.
Key event in the life cycle is when the server-side code
associated with an event triggered on the client. When
the user clicks on the button, the page posts back. Page
framework calls the RaisePostBackEvent. This
event looks up for the event handler and run the
associated delegate.
After PostBack event, page prepares for rendering.
PreRender event is called. This is the place where
user can do the update operations before the viewstate
is stored and output is rendered. Next stage is saving
view state, all the values of the controls will be saved
to their own viewstate collection. The resultant
viewstate is serialized, hashed, base24 encoded and
associated with the _viewstate hidden field.
Next the render method is called. This method
takes the HtmlWriter object and uses it to
accumulate all HTML text to be generated for the
control. For each control the page calls the render
method and caches the HTML output. The rendering
mechanism for the control can be altered by overriding
this render method.
The final stage of the life cycle is unload
event. This is called just before the page object is
dismissed. In this event, you can release critical
resources you have such as database connections, files,
graphical objects etc. After this event browser receives
the HTTP response packet and displays the page.