An HTTP request follows through a framework which is the MVC framework. For any web application, there are always two phases existing with the application. The first phase is responsible for creating the request, while the second phase is responsible for the response to the browser.
This article will focus on the lifecycle of the MVC application and how the application processes a request through its passing through the application’s components. Two life cycles are present in an MVC life cycle. These two life cycles are:
- The application life cycle
- The request life cycle.
Table of Contents
Application life cycle
Application life cycle generally means the time at which the process of the application begins to run. To denote the MVC application life cycle, the start and the end of the application are marked.
The request life cycle
The request life cycle means the series of events that happen whenever the application handles an HTTP request. Routing is the entry point for beginning any application of the MVC. When a request is made to the ASP.NET platform, the decision is taken on how to handle the request through the routing module. The term module means components of .NET, which are used for adding functionality into the code. It is the responsibility of the routing modules to match the URL that is incoming to the respective routes defined in the application. A route handler is associated with every route, which marks the point of entry into the framework of MVC.
The framework of MVC is responsible for handling the conversion of the route data into controllers that will further handle the requests. Once the creation of the Controller is done, the next step is taking action. This is done through the component of action invoker, which selects an action method to invoke the Controller.
Once the preparation for the action result is done, the next step is the result execution. A step of separation is created for the result from the result execution. For a view type result, the application will call the view engine, and it will find and help in rendering the view. If the result is not a view, execution of the action will take place on its own. It is the result execution that generates the actual response towards the original HTTP request.
Most of the components are known by the developers that they are used to process the request. In most cases, the methods and controllers related to the actions are being worked upon. Also, different action results and views are being worked upon. But there are other components too within the framework of MVC. There might be many questions in one’s mind about how the flow of requests is carried out through the different components or the HTTP module role and the handler while processing the request. The MVC framework being a framework of web development, there have to be modules of the HHTP and the HTTP handlers in the MVC pipeline of the framework.
Many components are present in the MVC page life cycle, apart from the Controller and the action methods.
This is a type of HTTP module. Whenever a request is first made, it is intercepted through the UrlRoutingModule. In this module, it is being decided upon whether the MVC application should handle the request. The UrlRoutingModule selects the first route that matches.
How is the request matched with those routes present in the MVC application through the UrlRoutingModule?
Looking at the method of RegisterRoutes, which is called from global.asax, the routes added to the RouteCollection of the routes could be seen. Calling of the method is done from the event handler at the application_start of global.asax.
How are the routes in the RouteHandler defined?
The routes are defined as extension methods, as it could be seen in the method of the maproute. The route handler is associated with all routes.
The method of the UrlRoutingModule is defined in the following way.
Through the above explanation, it can be known that the UrlRoutingModule knows all the routes that are defined in the application. Therefore, the correct route can be matched with the request in the application.
An important point to be noted is that the module UrlRoutingModule is involved in selecting the first matching route. So whenever the match has been detected, the process of scanning stops. If we summarize the thing that happens at this stage, the route handler is attached to the routes through the URLRoutingModule.
Through the method of the maproute, the routes get attached to the instances of the MvcRouteHandler. The interface IRouteHandler is implemented through the MvcRouteHandler.
Therefore, the object of the MvcRouteHandler is used for obtaining a reference for the thing of the MvcRouteHandler that is the application’s HTTPHandler.
Creation of the MvcRouteHandler, demands the calling of the method PostResolveRequestCache(). This method PostResolveRequestCache() can be defined in the following way:
Therefore, the following events occur at the PostResolveRequestCache() method.
- A GetRouteData() method is present in the RouteCollection property. The method is called and passed through the HttpContext.
- RouteData object is returned through the method of GetRouteData().
- a RouteHandler property is contained by the routeData that returns the handler IRouteHandler for the request, which is current, i.e., the MvcRouteHandler.
- The method GetHttpHandler() is associated with the MvcRouteHandler that returns a reference for the MvcHandler.
- Controls are then delegated to the instance of MvcHandler.
The MvcHandler is a normal handler of the HTTP. As it is a handler of the HTTP, the implementation of the method ProcessRequest() is carried out. This method ProcessRequest() can be defined as:
The method ProcessRequest() is used for calling the method ProcessRequestInit() as defined in the below image:
The following events occur at the method ProcessRequest().
- The ControllerFactory is created through the calling of the method ProcessRequestInit().
- The ControllerFactory creates the Controller.
- The Execute() method of the Controller’s is called.
One can observe that the ControllerFactory is obtained through the ProcessRequest() method. The ControllerFactory is then used to create the object of the Controller object. The interface IControllerFactory is implemented by the Controller factory.
BY DEFAULT, the MVC framework creates the type DefaultControllerFactory type when the ControllerBuilder is used for creating the ControllerFactory.
The following line of code creates the ControllerFactory in the method ProcessRequestInit().
It has been observed that the Controller object is created in the ControllerFactory in the method ProcessRequest() of the MvcHandler. The created Controller contains the methods for the actions that are to be taken by the framework. Whenever a request of URL is made in the browser, there is a calling of the method for the actions. The controllers are created so that there is no explicit implementation of the interface of the IControlle. The class Controller is used for creating the controllers that provide several features. The class of Controller can inherit another class of Controller which is called the “ControllerBase” as defined in the code shown below:
The ActionInvoker is used to call the methods of the actions in the Controller.
The following events occur after the creation of the Controller through the controller factory:
- Calling the method Execute() of controllerbase.
- The method ExecuteCore()is called by the method Execute() that is declared as abstract and is then defined through the class Controller.
- The action name is retrieved from the RouteData through the method ExecuteCore() by the class Controller.
- The method ActionInvoker’s InvokeAction() is called by the method ExecuteCore().
It is used for the selection of actions.
The class ActionInvoker has some important responsibilities that include finding an action method and then invoking the method of action in the Controller.
The events that occur when the method ActionInvoker’s InvokeAction() is called are:
- The information regarding the Controller has to be obtained by the ActionInvoker and the action that is needed to perform.
- The descriptor object’s provides this information.
- The controller name and the action name are provided by the descriptor class of the action and Controller.
- There is invoking the ActionMethod .
The ActionResult is a type of the abstract class. Being an abstract method, there are different implementations for the method ExecuteResult() provided by the different sub-classes.
The following events occurs in the ActionResult
- There is an invocation of the methods of OnActionExecuting of the ActionFilters.
- Invoking of the method action.
- Invoking of the methods OnActionExecuted methods of ActionFilters.
- There is a return of the ActionResult from the ActionMethod
- Calling the method ExecuteResult() of the ActionResult.
Most of the applications use ViewResult as their return type. A view is rendered through the ViewEngine to the client. From this view, the HTML can be generated. The HTML is generated from the view through the ViewEngine.
Understanding the role of every component in the application is a crucial step. This way, the connections between the components and their way of working can be understood. If you want to be an experienced developer, then mastering your skills is one way. You can check out the Online Software Engineering Courses of upGrad which will give you certification and expert training in the area of developing applications and software. The course is designed for both male and female working professionals and is certified from IIIT-B, and you will get their Alumni Status.