Table of Content: –
- What is MVC Application?
- Components of MVC
- Life Cycle of MVC Application
- URL Routing Module
- MVC Handler
- Controller Execution
- Action Result
- Rendering View
This article will find the easiest way to learn or grab things about the MVC application life cycle. It will also help you understand some of the most difficult things about the MVC application in the easiest way possible. So, tie your seats & buckle up your belts. This will be an amazing ride that you have never expected.
What is MVC APPLICATION?
The Model View Controller, also known as MVC, is an architectural pattern whose only the main objective is to separate an application into three main logical components. The first component is the model, the second component is the view, and the third last component is the controller. The real motive of all these components is to handle specific development aspects of an application.
Moreover, MVC is one of the most frequently used industrial techniques for the web development framework to create scalable and extensible applications projects.
Let’s know more about the component of MVC. So, you don’t face any problem understanding the life cycle of MVC applications. The details about the component are: –
Components of MVC
- MODEL – In MVC, the Model component is used for all the data related to the user’s logic. Apart from all that, it also represents either the data that is being transferred between the View and Controller components or any other business logic related data.
- VIEW – In MVC, the View component is used for all the UI logic behind the application. To understand it better, let’s take an example of the customer view. The Customer view will include all the UI components such as text boxes, dropdowns, etc. The final user can interact with the MVC application.
- CONTROLLER – In MVC, The controller is used as an interface between Model and View components. It helps in processing all the business logic and incoming requests. Moreover, it also manipulates data using the Model component and interacts with the views to render the final output.
Now we are ready to understand the life cycle of MVC Applications. So, without wasting any moment, let’s grab this as well.
Life Cycle of MVC Application
The life cycle of the MVC Application is divided into six parts. While creating an application through the MVC technique, a developer needs to go through every part of this life cycle. The parts of the MVC Application life cycle are: –
- • Routing
- • URL Routing Module
- • MVC Handler
- • Controller Execution
- • Action Result
- • Rendering View
Let’s understand this process briefly in the below paragraphs.
When a developer starts creating an application through the MVC technique, he initially needs the Application Start method that is called Global asax. Using this, a developer can register Route tables in the given application. The route table is basically a collection of the route which are defined in a route configurations file.
When you open Route configuration .cs in your project, you will see the C# code below, which is the default route configuration in MVC, you need to use to route the application for the start method.
URL Routing Module
In the second part, a developer needs to move towards the URL Routing module. URL routing module is used for mapping user requests towards particular controller actions, and it also provides a base for the application.
To understand it better, let’s take an example. This who stop work on according to the user request of URL Routing Module to find URL in Route table to create Route Data Object. If it finds a correct match for a request, it creates a request context object and sends the request to MVC Handler. As soon as a match is found, the scanning of the route table process stops, and the developer needs to move towards the next step.
Basically, this step of MVC Handler is responsible for initiating the actual processing of the ongoing request and generating a response for its user, which is why it is so important. MVC Handler gets information of current request through request context of the user’s object passed to its constructor.
It received the information about the request from the request context object and passed it to the constructor to get the HTTP Handler method in the MVC Route Handler.
This step is one of the easiest steps of the MVC application life cycle. In this step, a developer needs to use an MVC controller to implement the IController interface in the application. It is also known as an Execute method representing a particular action of its user.
In this, the controller action invoker determines which action needs to be executed and how they need to execute the action.
This step includes the further process of the last step. In the last step, the developer clarifies the Action Method execution with the logic. Now he needs to return back to the start of an Action Result to develop on what base the type of Result it returns. This all works on View & generates accordingly to the user. Before, we also had some Action Filter methods, which is invoked based on the Action Method’s life cycle. Some methods include On Action Executing & on Action Executed, etc.
Let’s know some of the Action Result types as well for your better understanding. The Action Result types are: –
• View Result: Returns a view (html type page)
• Redirect Result: Redirects to another action method
• Content Result: Returns Content (user-defined)
• Jason Result: Returns a serialized JSON data
Moreover, if a developer does not want any specific method to be accessible through a public URL, he can mark that method with the Non-Action attribute.
Now, the final step of the MVC Application life cycle is about rendering the View of the application. In this step, the user can see what he requested and respond to its question. Here, the View Result one of the action results will generate the appropriate View for the user by parsing the Razor syntax (cshtml) and server-side codes into the HTML page for the Client.
View result implements the IView Engine Interface and also has some view manipulating methods such as:
• Release View: To release the View
• Find View: Maps the appropriate View
• Find Partial View: Returns a Partial View
After this step, the life cycle of the MVC Application gets over.
I hope this article has cleared all your basic problems & helped you to understand more about the MVC life cycle of application architecture.