ASP.NET Life Cycle

标签：

The ASP.NET platform defines two important life cycles. The first is the application life cycle, tracks the life of a web application from the moment it starts to the moment it is terminated. The second is request life cycle, defines the path that an HTTP request follows as it moves throught ASP.NET platform from the point at which the initial request is received until the response is sent. 

1. Application life cycle

The life cycle of an ASP.NET application begins the moment the application is started and continues while HTTP requests are received from the clients. And the life cycle ends when the application is stopped. 

ASP.NET platform provides notifications of the two stages of life cycle through methods defined by the global.ascx.cs file. 

    public class MvcApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            RouteConfig.RegisterRoutes(RouteTable.Routes);
        }
    }

The default global class is called MvcApplication and derived from System.Web.HttpApplication. 

1.1 receiving notifications when application starts and ends

The global class supports two special methods that define the start and end of the application lifecycle. 

The application_start methods is called when the application is first started and provides an opportunity to perform one-off configuration tasks, such as set up areas and routes. The application_end method is called just before the application is terminated and is an opportunity to release any resources. 

Both methods are not defined by the base for the global class, rather asp.net framework uses reflection to look for the methods by name. 

2. Request life cycle

The request life cycle is described by a secries of events that describe the progress of a request from when it is received through until the response is sent. 

You are free to trigger these events through the processing life cycle. You can handle these events in the global application class, in a module, or in a handler. 

3. Understanding modules and hanlders

You can respond to request life cycle events directly in the global application class, but it is only situable for simplest of interactions with request. The ASP.NET framework deals with this by supporting modules, which are self-contained class that receive lifecycle events and can monitor and manipulate request. Also, ASP.NEt supports a component called handler, which is responsible for generating a response for a request. The hanlder in MVC framework is responsible for locating a controller and action method to service a request and rendering view. 

Note that the global application class is instantiated by both application and request life cycle. Not only does the asp.net framework create multiple instances to service parallel request, but it also creates separate instances to support each life cycle. 

4. Handling Request life cycle events using special methods

To handle these events in the global application class, you create a method with a name that starts with Application_, followed by the event name, such as Application_BeginRequest.

        protected void Application_BeginRequest()
        {
            RecordEvent("BeginRequest");
        }

        protected void Application_AuthenticateRequest()
        {
            RecordEvent("authenticate request");
        }

        protected void Application_PostAuthenticateRequest()
        {
            RecordEvent("Post authenticate request");
        }

These events will be called when the BeginRequest, AuthenticateRequest, and PostAuthenticateRequest events are triggered. The ASP.NET framework will invoke these methods automatically. 

4.1 Handling request life-cycle without special method

HttpApplication class defines regular C# events that can be used instead of special methods. 

        public MvcApplication()
        {
            BeginRequest += (sender, args) => RecordEvent("BeginRequest");
            AuthenticateRequest += (sender, args) => RecordEvent("AuthenticateREquest");
            PostAuthenticateRequest += (sender, args) => RecordEvent("PostAuthenticateRequest");
        }

4.2 Using single method to handle multiple events

You can use two properties defined by the System.Web.HttpContext class if you want to use a single method to handle multiple life-cycle events without relying onlambda expressions. HttpContext provides details of the current request and the state of the application. 

        private void RecordEvent(object src, EventArgs args)
        {
            var eventList = Application["events"] as List<string>;
            if (eventList == null)
            {
                Application["events"] = eventList = new List<string>();
            }

            string name = Context.CurrentNotification.ToString();
            if (Context.IsPostNotification)
            {
                name = "Post" + name;
            }

            eventList.Add(name);
        }

5. ASP.NET Context objects

ASP.NET provides a set of objects that are used to provide context information about the current request, response and web application itself. The core class is System.Web.HttpContext. It is universally available throughout the ASP.NET framework and the MVC framework. The important properties are as following:

The HttpContext is available through:

If the model needs information about a request, then obtain this information from the context objects in the controller and pass it as method arguments. 

5.1 working with HttpApplication object

HttpApplication is the base class for the global application class. 

The request, response, session and User properties all return values of the corresponding properties from the HttpContext, but it will throws an HttpException if the value they get from HttpContext is null. This happens because the HttpApplication class receives notifications for two different life cycle: the application life cycle and the request life cycle. 

5.2 working with HttpRequest objects

HttpRequest object describes a single HTTP request as it is being processed. 

You can obtain HttpRequest:\

Additional properties in HttpRequest:

5.3 Working with HttpResponse objects

It provides methods and properties that let you customize the response. 

ASP.NET Life Cycle

标签：

原文地址：http://www.cnblogs.com/timBo/p/4596657.html