ASP.NET Core web apps are based on the popular MVC Design pattern. MVC Pattern stands for Model-View-Controller Pattern. In this Tutorial, we learn what is MVC and in the subsequent tutorial, we will see how to use MVC Design pattern in ASP.NET Core.
Table of Contents
MVC Design Pattern in ASP.NET Core
MVC Design Pattern is a popular design pattern used in the Presentation layer. ASP.NET Core MVC follows the tried and tested MVC Design pattern at its core and everything revolves around it.
MVC is a powerful and elegant means of separating concerns within an application. MVC Architecture splits the application into three separate and distinct layers. The Model layer, View Layer and the Controller Layer.
Each of these layers has very specific set of responsibility. The Model layer contains the data. The View renders the Model to the user and handles user interactions. The View passes the user interactions to the Controller, which in turn builds the model and update the View.
Separation of concerns
The Separation of concerns philosophy states that each component of the application is responsible for only one thing. They should do not depend upon any other component as much as possible. In other words, the components should be loosely coupled with other. The application built using such a concept is easily testable, maintainable and extensible.
The MVC Pattern follows the separation of concerns philosophy. Each of the three layers in MVC can be developed and tested independent of each other and combined together to create a robust application.
The important point to note here is that the MVC Pattern is Presentation layer pattern. It only deals with the how & when the data is presented to the User. You need to use this pattern along the data access layer and business layer etc. to create a Complete web application.
The model represents the data that needs to be shown to the user and some associated logic. It is an object or just another c# class with properties and methods.
The model does not and should not depend on Controller or View. The only responsibility of the model is to hold the data. The model class is ideally reusable.
The view is a visual representation of the model. It is the responsibility of the View is to take the model from the controller, render and present it to the user. The view is hooked to a model and access its data and shows it to the user. it may update the model and sends it back to the controller for database updating. The view will never access the business layer or the data layer.
A View has following responsibilities
- Responsible for interacting with the User
- Render the model to the user
- Accept User interaction and pass it to controller
- Should be able to Render JSon, XML and custom return types
The Controller receives the request. It then builds the model and selects the view to display it. It sits between View and the model. You can think of it as a glue which joins Model to the View. it controls the flow of activity.
The Controller should not become a dumping ground for your code. It should always delegate the work to the service layer (For example data layer to get the data, business layer to execute the business logic etc) to build and get the model. The model then, should be injected into the view for rendering the View.
The Controller has following responsibilities
- Process incoming requests from the user.
- The controller then passes the request to appropriate Service layer gets the model.
- Pass the model to view for rendering.
- Passes the validations and errors back to View if any.
- The controller never accesses the data layer.
The controller acts on both model and view. It controls the data flow into the model object and updates the view whenever data changes. It keeps view and model separate
How MVC Pattern works in ASP.NET Core
We looked at the Various components of the MVC Pattern. Now let us see how all the pieces work together
The request starts, when the user clicks on a button, on a link or entering the URL in the Browser. For Example, the following request coming from the User
The above request arrives at the MVC Middleware after Passing through the Request Pipeline. We looked at Middleware & Request Pipeline here.
The MVC Middleware inspects the URL and decides which controller to invoke. The Process of mapping the request to the controller as called Routing.
MVC Middleware invokes the Controller and passes the user request.
The Controller now looks at the user request and decides what to do with it. The Request may be to insert the new customer or get the list of Customers. The Controller builds the appropriate model. It will call the service layer to complete its task.
The Controller passes the model to the appropriate view and passes the control to view to build the response.
The View will generate the appropriate response. The response could be an HTML, XML, Json or a file to download. It then sends it back to the user.
The Request cycle completes and the app waits for the further user interaction, which will start a fresh cycle.
In this tutorial, we learned what is MVC Design Pattern is as applied to ASP.NET Core MVC Apps. We looked at the three important components of the MVC i.e Model, View and Controller. We looked at Role and responsibilities of each layer. Finally, we learned how the MVC Pattern works in ASP.NET Core MVC apps.
In the next tutorial, let us build a Simple MVC app from scratch and add Model, View and Controller and see how the three works together
2 thoughts on “MVC Design Pattern in ASP.NET Core”
The best and the the clearest explanation of MVC I’ve ever read. Thanks!