Model View and Controller (MVC) in ASP.Net

Harpreet Singh
9y
13k
0
1

Article

What does MVC look like?
MVC

Models encapsulate the objects and data. It consists of all the business logic.

Views generate the user interface, like tables, forms and so on.

Controllers interact with user actions. It takes care of all the magic that happens. It gets the request from the user, gets the information and if required then passes it to the model, lets the model do its thing and then the controller passes it to the view and the view displays the data.

Note

We control the UI of the view. So, based on our logic of HTML, the data is displayed.

All the code is in .cshtml and .cs files.

In MVC we have a precise control of HTML and URLs.

Controller

The Controller is the building block of a MVC project. The Controller is a class present in the System.Web.Mvc namespace.

All the incoming requests are handled by the Controller.

How to create a controller

Step 1

Open Visual Studio and click "New Project...".

Step 2

In the installed template, expand Visual C# and then expand Web. Select the Visual Studio 2012 template and then choose ASP.NET MVC 4 web application, give a meaningful name and click OK.

Step 3

Select the project template as empty and view engine as Razor. Click OK.

Step 4

Visual Studio will create a project with minimal layout with auto-generated Models, Views and Controllers directory.

Step 5

In MVC, it is very important to follow the naming convention. By default, every controller name should be suffixed with Controller and must be present inside the Controllers directory.

To add a controller, right-click on the controllers directory then select Add -> Controller.

Step 6

Provide controller a name such as HomeController (we will discuss it in just a bit) and scaffolding option template as Empty MVC controller.

In the Solution Explorer, you will see App_Start directory. This directory contains a RouteConfig class that contains the routing configuration that is followed by every MVC application.

There is a static method RegisterRoutes that contains the routing information.

There are two properties, IgnoreRoute and MapRoute, out of which routes.MapRoute contains the routing information of the application.

Name: The name of the route.
URL: The format in which the users must type the URL in the address bar of the web browser.
Defaults: It is the default routing configuration.
Controller: By default, it is Home which means when we run this application it will look for a Home controller but it is customizable.
Action: By default, Index is the action method that our HomeController will look for.
Id: It is a parameter value that the user may or may not specify. It is optional.
For starters this is the reason we named our controller HomeController.

Step 7: Open the HomeController.cs file and repare to work with it.

When we created a HomeController class, it inherits from the controller class that is present in System.Web.Mvc that gives us an Index public method. The action method must be public and all the public methods inside a controller class are termed Action Methods. By default these methods return ActionResult objects.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
namespace MvcApplication1.Controllers {
public class HomeController : Controller {
public ActionResult Index() {
//to display a content, we can use the content method
return Content("This is a content");
//file download
return File(Server.MapPath("~/App_Data/ABC.pdf"), contentType: "application/pdf", fileDownloadName: "A.pdf");
//to redirect to other action method, use RedirectToAction
return RedirectToAction("GetDetails");
}
public ActionResult GetDetails() {
return Content("GetDetails");
}
}
}

We can have different methods with the same name but with different method signatures that we know as method overloading.

So, can we use the same logic here too? Let's look at an example.

public class HomeController : Controller {
public string Index() {
return "IndexOne output";
}
public string Index(string id) {
return id;
}
}

Now, run the application. We will get an ambiguous error.

To overcome this issue, we can use the ActionName attribute ActionName.

public class HomeController : Controller {
public string Index() {
return "IndexOne output";
}
[ActionName("Index_Two")]
public string Index(string id) {
return "My value " + id;
}
}

Run the application

When we run our application, MVC will look for the default routeConfig where the controller name is Home and the action method is Index. If the match is found, it will display the content.

The ActionName “Index_Two” will be treated as the action method name of the second Index(int id) method.

And if you want to go to the another Index action method, then type the following in the URL.

URL
Press Enter.

index two output
Models

The basic key point you must be familiar with model is that it is just a class file that can hold a simple type or complex type data.

Models can be entities or business objects.

When a user requests a URL, the controller responds to URL request, if required, then it gets data from a model and hands it over to the view. Then the view renders the data and displays the data to the front-end users in HTML format.

DEMO on how to add a Model

Step 1

Open Visual Studio -> select New Project -> expand Installed templates -> expand visual C# -> expand web -> select Visual Studio as template -> select ASP.NET MVC 4 web application as a project -> provide a meaningful name then click OK.

project

Step 2

Select the project template as Empty and view engine as Razor.

Class

Click OK

Step 3

To create a controller class what we did was to go to the Solution Explorer, select the controllers folder, right-click on the controllers folder, add, controller. To add a model we need to do the same thing.

To add a model class, go to the Solution Explorer then select the models folder then right-click on the models folder then select Add -> Class.

Provide a meaningful name.

Here I will be creating a Student model.

Click Add.

Step 4

Write the following code in the student class.

public class Students {
public int StudentId { get; set; }
public string Name { get; set; }
public double TotalMarks { get; set; }
}

Note

The code inside the Student class is nothing more than an auto-implemented property.

So, our model is created.

In real time we retrieve the data from the database using a model. But for here we hardcoded the values in our Controller class.

Step 5

The next step is to add a controller. The reason to add a controller is that without a Controller we won't be able to pass the model data to the view and to pass the data to the view we need a controller.

So, right-click on the Controllers folder then select Add -> Controllers.

Provide the name HomeController and select the scaffolding template as Empty MVC controller.

Click Add.

Step 6

In our Index action method of HomeController, we will create an instance of our student class and pass the value for the properties. But before that there is one thing you must look at carefully.

In the Student model class, you will see that our Student class is present in ModelsDemo.Models and our Controller class is present in the ModelsDemo.Controllers. So, to use the Student class in our Controller class we need to import the ModelsDemo.Models namespace.

using ModelsDemo.Models;

In our Index action method, write the following code:

using ModelsDemo.Models;
using System.Web.Mvc;
namespace ModelsDemo.Controllers {
public class HomeController : Controller {
public ActionResult Index() {
Students student = new Students() {
StudentId = 2,
Name = "Max Payne",
TotalMarks = 450.5
};
return View(student);//pass the object student to the view
}
}
}

Views

Views are nothing more than a HTML file.

It is used to display the requested data for the users. In simple terms, whatever we see as output in a web browser is a view.

Step 7

The final step is to create a view and to create a view all we need to do is right-click on the Index action method and select Add view.

The View name should be Index matching the action name.

The View engine should be Razor (CSHTML).

Select the "Create a strongly-typed view" checkbox and select the model class which is Students.

Note

If you don't find the students model class then click the Cancel button and press Ctrl+Shift+B or F6 that will build the project and now again right-click on the Index action method and selected the model class as Students.

Click Add.

The reason for creating a strongly typed view is, we will get a compile time error and intellisense. Explains this more in the next article.

Step 8

The next step is to write some HTML code and some C# code that will be rendered and displayed to the front-end user and to do that first write the following codes to create a table.

@model ModelsDemo.Models.Students
@{
ViewBag.Title = "Index";
}
<h2>Index</h2>
<table>
<tr>
<td><b>Student Id - </b></td>
<td></td>
</tr>
<tr>
<td><b>Student Name - </b></td>
<td></td>
</tr>
<tr>
<td><b>Student Marks - </b></td>
<td></td>
</tr>
</table>

So, we have a layout that will display the records. But from where we will get the student records?

In our controller's Index action method we have passed the employee object as a parameter in the View method and we have all created this view as a strongly-typed view and select model class as Students. So, our model for this view is student and all the records are present in this model.

Note

To switch between the HTML and C#, use the @ symbol.

So, we can say:

<tr>
<td><b>Student Id - </b></td>
<td>@Model.</td>
</tr>

HTML

This will give us all the properties present in this model that is nothing but a Student class object.

Note

This model property is a get property that will only return the properties associated within our class object.

View codes