TechnologyMvc

tempdata

2019-04-26T22:17:00.002+05:30

ASP.NET MVC offers us three options - TempData for passing data from controller to view and in next request.

TempData is also a dictionary derived from TempDataDictionary class and stored in short lives session and it is a string key and object value. The difference is the life cycle of the object. TempDatakeeps the information for the time of an HTTP Request. This means only from one page to another. This also works with a 302/303 redirection because it’s in the same HTTP Request. It helps to maintain data when you move from one controller to another controller or from one action to other action. In other words, when you redirect, “Tempdata” helps to maintain data between those redirects. It internally uses session variables. Temp data use during the current and subsequent request only means it is used when you are sure that the next request will be redirecting to next view. It requires typecasting for complex data type and check for null values to avoid an error. It is generally used to store only one time messages like error messages, validation messages.

Example: TempData

public ActionResult Index()
{
var model = new Review()
{
Body = "Start",
Rating=5
};
TempData["Data"] = model;
return RedirectToAction("List");
}

public ActionResult List()
{
var model= TempData["Data"];
return View(model);
}

1. TempData is a dictionary object that is derived from the TempDataDictionary class and stored in short lives session.

2. TempData is used to pass data from current request to subsequent request (means redirecting from one page to another).

3. Its life is very short and lies only till the target view is fully loaded.

4. It’s required typecasting for getting data and check for null values to avoid the error.

5. It’s used to store only one time messages like error messages, validation messages.

Persist data in TempData

The life of TempData is very short and lies only until the target view is fully loaded. But you can persist data in TempData by calling Keep() method after request completion

void Keep() - Calling this method within the current action ensures that all the items in TempData are not removed at the end of the current request.

public ActionResult Index()
{
ViewBag.Message = TempData["Message"];
Student student = TempData["student"] as Student;
//need type casting TempData.Keep();
//persist all strings values
return View();
}

void Keep(string key) - Calling this method within the current action ensures that specific item in TempData is not removed at the end of the current request.

public ActionResult Index()
{
ViewBag.Message = TempData["Message"];
Student student = TempData["student"] as Student; //need type casting
//persist only data for student key and Message key will be destroy
TempData.Keep("student");
return View();
}

Create first simple MVC application

2019-04-26T20:32:00.000+05:30

First of all, open a Visual Studio 2013 for Web and click on a New Project link in the Start page. Alternatively, you can also select File menu -> New Project.

From the New Project dialog as shown below, expand Visual C# node and select Web in the left pane, and then select ASP.NET Web Application in the middle pane. Name your project MVC-BasicTutorials. (You can give any appropriate name for your application). Also, you can change the location of the MVC application by clicking on Browse.. button. Finally, click OK.

From the New ASP.NET Project dialog, select MVC as shown below.

Add caption

You can also change the authentication by clicking on Change Authentication button. You can select appropriate authentication mode for your application. Here, we are not going to have any authentication for our application. So select No Authentication radio button and click OK. (By default, Individual User Accounts would be selected to authenticate users stored in SQL Server database.)

Wait for some time till Visual Studio creates a simple MVC project using default template as shown below.

Now, press F5 to run the project in debug mode or Ctrl + F5 to run the project without debugging. It will open home page in the browser as shown below.

MVC 5 project includes JavaScript and CSS files of bootstrap 3.0 by default. So you can create responsive web pages. This responsive UI will change its look and feel based on the screen size of the different devices. For example, top menu bar will be changed in the mobile devices as shown below.

Viewbag

2019-04-09T15:19:00.001+05:30

We have learned Viewbag in the previous section that the model object is used to send data in a razor view. However, there may be some scenario where you want to send a small amount of temporary data to the view. So for this reason, MVC framework includes ViewBag.

It is used to allow you to share values dynamically. There are several variables that are not known before the program is run, and these values are only entered during runtime. And this is where it shines, because you can put just about anything you want in ViewBag.

ViewBag can be useful when you want to transfer temporary data (which is not included in model) from the controller to the view. The viewBag is a dynamic type property of ControllerBase class which is the base class of all the controllers.

The following figure illustrates the ViewBag.

In the above figure, it attaches Name property to ViewBag with the dot notation and assigns a string value "Rohit" to it in the controller. This can be accessed in the view like @ViewBag.Name. (@ is razor syntax to access the server side variable.)

You can assign any number of properties and values to ViewBag. If you assign the same property name multiple times to ViewBag, then it will only consider last value assigned to the property.

Note:
ViewBag only transfers data from controller to view, not visa-versa. ViewBag values will be null if redirection occurs.
The following example demonstrates how to transfer data from controller to view using ViewBag

Example: Set ViewBag in Action method

namespace MymvcFirstApplication.Controllers
{
public class StudentController : Controller
{
IList studentList = new List() {
new Student(){ StudentID=1, StudentName="Rohit", Age = 21 },
new Student(){ StudentID=2, StudentName="Rames", Age = 25 },
new Student(){ StudentID=3, StudentName="Ronak", Age = 20 },
new Student(){ StudentID=4, StudentName="Ritik", Age = 31 },
new Student(){ StudentID=5, StudentName="Rahul", Age = 19 }
new Student(){ StudentID=6, StudentName="Rokl", Age = 23}
};
// GET: Student
public ActionResult Index()
{
ViewBag.TotalStudents = studentList.Count();

return View();
}

}
}

In the above example, we want to display the total number of students in a view for the demo. So, we have attached the TotalStudents property to the ViewBag and assigned the student count using studentList.Count().

Now, in the Index.cshtml view, you can access ViewBag.TotalStudents property and display all the student info as shown below.

Example: Acess ViewBag in a View

Total Students: @ViewBag.TotalStudents

Output:
Total Students: 6

ViewBag doesn't require typecasting while retriving values from it

Points to Remember :

1.ViewBag transfers data from the controller to the view, ideally temporary data which in not included in a model.

2.ViewBag is a dynamic property that takes advantage of the new dynamic features in C# 4.0

3.You can assign any number of propertes and values to ViewBag

4.The ViewBag's life only lasts during the current http request. ViewBag values will be null if redirection occurs.

5.ViewBag is actually a wrapper around ViewData

Razor Syntax in MVC

2019-04-04T13:56:00.001+05:30

Razor is one of the view engine supported in ASP.NET MVC. Razor allows you to write mix of HTML and server side code using C# or Visual Basic. Razor view with visual basic syntax has .vbhtml file extension and C# syntax has .cshtml file extension.

Razor syntax has following Characteristics:

    Compact: Razor syntax is compact which enables you to minimize number of characters and keystrokes required to write a code.
    Easy to Learn: Razor syntax is easy to learn where you can use your familiar language C# or Visual Basic.
    Intellisense: Razor syntax supports statement completion within Visual Studio.

how to write razor code.
Start with @ symbol to write server side C# or VB code with Html code. For example, write @Variable_Name to display a value of a server side variable. For example, DateTime.Now returns a current date and time. So, write @DateTime.Now to display current system datetime as shown below. A single line expression does not require a semicolon at the end of the expression

Razor Syntax of example

C# Razor Syntax
Razor syntax demo

@DateTime.Now.ToShortDateString()

Output:
Razor syntax demo
22-12-2018 //Current date show my computer system

Multi-statement Code bloc
You can write multiple line of server side code enclosed in braces @{ ... }.
Each line must ends with semicolon same as C#.

Example: Server side Code in Razor Syntax

@{
      var date = DateTime.Now.ToShortDateString();
       var message = "Hello Friends";

}

Today's date is: @date

@message

Output:
Today's date is: 08-09-2014
Hello World!

Display Text from Code Block
Use @: or / to display

texts within code block.

Example: Display Text in Razor Syntax

@{

    var date = DateTime.Now.ToShortDateString();

    string message = "Hello World!";

    @:Today's date is: @date

    @message

}

Output:
Today's date is: 08-09-2014

Hello World!

Display text using within a code block as shown below.

Example: Text in Razor Syntax

@{

    var date = DateTime.Now.ToShortDateString();

    string message = "Hello World!";

    Today's date is: @date

    @message
}

Output:
Today's date is: 08-09-2014
Hello World!

Condition Write

If statement
It starts with code block and its condition is written in parenthesis. And the code which needs to be executed once condition gets satisfied is written inside braces.

Let’s understand with the below example.

@{var price=60;}


      @if (price>50)
       {
          The price is greater than 50.

       }

In the above example, we have declared var price has a value of 60 and we are using if statement which is validating price. If the price is greater than 50 then the code written in side braces gets executed.

If – Else statement
It starts with code block and its condition is written in parenthesis. And code which needs to be executed once the condition gets satisfied is written inside braces and if it does not gets satisfied then code written inside else block gets executed.

Let’s understand with the below example.

@{var price=60;}

@if (price>50)
    {
    The price is greater than 50.

}

else
{
The price is less than 50.

}

In the above example, we have declared var price having a value of 60 and we are using if statement which is validating price. If the price is greater than 50 then the code written inside braces gets executed else the price is less than 50 and it will get executed.

Loops

Loops are used for executingthe same statement multiple times.

For Loops
If you know how many times you want to run the loop, you can use a For loop.


      @for(var i = 0; i < 10; i++)
       {No @i
}


      @for(var i = 0; i < 10; i++)
       {No @i
}


For Each Loops
Foreach loop is used when you are working with collections or an array.

Model

Use @model to use model object anywhere in the view.

Example: Use Model in Razor

@model Book
BookDetail:

    BookId: @Model.BookId

    Book Name: @Model.BookName

    Book Page: @Model.BookPage

Output: Book Detail :

- BookId: 1001

- Book Name: Abc

- Book Page: 18

Declare Variables

Declare a variable in a code block enclosed in brackets and then use those
variables inside html with @ symbol.

Example: Variable in Razor

@{

    string str = "";

if(1 > 0)
   {
     str = "Hello World!";

    }

}

@str

Output:

Hello World!

Model in MVC

2019-03-21T11:51:00.000+05:30

In this section, you will learn about the Model in ASP.NET MVC framework.

Model represents domain specific data and business logic in MVC architecture. It maintains the data of the application. Model objects retrieve and store model state in the persistance store like a database.
Model class holds data in public properties. All the Model classes reside in the Model folder in MVC folder structure.
Let's see how to add model class in ASP.NET MVC.

Adding a Model

Open our first MVC project created in previous step in the Visual Studio. Right click on Model folder -> Add -> click on Class..
In the Add New Item dialog box, enter class name 'Student' and click Add.

Create Model Class

This will add new Student class in model folder. Now, add Id, Name, Addredss, Age, Gender properties as shown below.

For Example: Model class

namespace FirstMVCApplication.Models
{
public class Student
{
public int Student_Id { get; set; }
public string Name { get; set; }
public string Address{ get; set; }
public string Age { get; set; }
public string gender { get; set; }
}
}

So in this way, you can create a model class which you can use in View. You will learn how to implement validations using model later.
Learn how to create a View in the next section

Action selectors in Mvc

2019-03-20T20:04:00.003+05:30

Action Selectors

Action selector is the attribute that can be applied to the action methods. It helps routing engine to select the correct action method to handle a particular request. MVC 5 includes the following action selector attributes:

ActionName

NonAction

ActionVerbs

1. ActionName

ActionName attribute allows us to specify a different action name than the method name. Consider the following example.

Example: ActionName

public class BookController : Controller

    public BookController()

    [ActionName("find")]

    public ActionResult GetById(int id)

        // get Book from the database

        return View();

In the above example, we have applied ActioName("find") attribute to GetById action method. So now, action name is "find" instead of "GetById". This action method will be invoked on http://localhost/Boook/find/1 request instead of http://localhost/Book/getbyid/1 request.

3. NonAction

NonAction selector attribute indicates that a public method of a Controller is not an action method. Use NonAction attribute when you want public method in a controller but do not want to treat it as an action method.
For example, the GetStudent() public method cannot be invoked in the same way as action method in the following example.

Example: NonAction

public class BookController : Controller

    public BookController()

    [NonAction]

    public Book GetBook(int id)

        return BookList.Where(s => s.BookId == id).FirstOrDefault();

3. ActionVerbs

You can apply these attributes to action method to indicate the kind of Http request the action method supports. If you do not apply any attribute then it considers it a GET request by default

[HttpGet], [HttpPost], [HttpPut], [HttpDelete] Attributes in ActionSelectors

[HttpGet] - It is used to restrict an action method to handle only HTTP GET requests.

[HttpPost] - It is used to restrict an action method to handle only HTTP POST requests.

[HttpPut] - It is used to restrict an action method to handle only HTTP PUT requests.

[HttpDelete] - It is used to restrict an action method to handle only HTTP DELETE requests.

Example: ActionVerbs

public class BookController : Controller

    public BookController()

    [HttpGet]

    public Book GetBook(int id)

        return BookList.Where(s => s.BookId == id).FirstOrDefault();

Points to Remember :

MVC framework routing engine uses Action Selectors attributes to determine which action method to invoke.

Three action selectors attributes are available in MVC 5:

ActionName, NonAction, ActionVerbs

ActionName attribute is used to specify different name of action than method name.

NonAction attribute marks the public method of controller class as non-action method. It cannot be invoked.

Action methods in mvc

2019-03-20T14:40:00.002+05:30

Understanding Controllers

MVC controllers are responsible for responding to requests made against an ASP.NET MVC website. Each browser request is mapped to a particular controller. For example, imagine that you enter the following URL into the address bar of your browser:

http://localhost/Student/Index

In this case, a controller named StudentController is invoked. The StudentController is responsible for generating the response to the browser request.

For example, the controller might return a particular view back to the browser or the controller might redirect the user to another controller.

Listing 1 contains a simple controller named StudentController.

Listing1 - Controllers\StudentController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Mvc.Ajax;

namespace FirstMvcApplication1.Controllers
{
public class StudentController : Controller
{
//
// GET: /Student/

public ActionResult Index()
{
// Add action logic here
return View();
}
}

}

As you can see from Listing 1, a controller is just a class (a Visual Basic .NET or C# class). A controller is a class that derives from the base System.Web.Mvc.Controller class. Because a controller inherits from this base class, a controller inherits several useful methods for free

(We discuss these methods in a moment).

Understanding Controller Actions

A controller exposes controller actions. An action is a method on a controller that gets called when you enter a particular URL in your browser address bar.

For example, imagine that you make a request for the following URL: http://localhost/Student/Index

In this case, the Index() method is called on the StudentController class. The Index() method is an example of a controller action.

A controller action must be a public method of a controller class. C# methods, by default, are private methods. Realize that any public method that you add to a controller class is exposed as a controller action automatically

(You must be careful about this since a controller action can be invoked by anyone in the universe simply by typing the right URL into a browser address bar).

There are some additional requirements that must be satisfied by a controller action. A method used as a controller action cannot be overloaded. Furthermore, a controller action cannot be a static method. Other than that, you can use just about any method as a controller action.

Understanding Action Results Types

A controller action returns something called an action result. An action result is what controller action returns in response to a browser request.

The ASP.NET MVC framework supports several types of action results including:

1. ViewResult - Represents HTML and markup.

2. EmptyResult - Represents no result.

3. RedirectResult - Represents a redirection to a new URL.

4. JsonResult - Represents a JavaScript Object Notation result that can be used in an AJAX application.

5. JavaScriptResult - Represents a JavaScript script.

6. ContentResult - Represents a text result.

7. FileContentResult - Represents a downloadable file (with the binary content).

8. FilePathResult - Represents a downloadable file (with a path).

9. FileStreamResult - Represents a downloadable file (with a file stream).

All of these action results inherit from the base ActionResult class.

In most cases, a controller action returns a ViewResult.

For example, the Index controller action in Listing 2 returns a ViewResult.

Listing 2 - Controllers\BookController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Mvc.Ajax;

namespace FirstMvcApplication1.Controllers
{
public class BookController : Controller
{
// GET: /Book/
public ActionResult Index()
{
// Add action logic here
return View();
}
}

}

When an action returns a ViewResult, HTML is returned to the browser. The Index() method in Listing 2 returns a view named Index to the browser.

Notice that the Index() action in Listing 2 does not return a ViewResult(). Instead, the View() method of the Controller base class is called. Normally, you do not return an action result directly. Instead, you call one of the following methods of the Controller base class:

1. View - Returns a ViewResult action result.

2. Redirect - Returns a RedirectResult action result.

3. RedirectToAction - Returns a RedirectToRouteResult action result.

4. RedirectToRoute - Returns a RedirectToRouteResult action result.

5. Json - Returns a JsonResult action result.

6. JavaScriptResult - Returns a JavaScriptResult.

7. Content - Returns a ContentResult action result.

8. File - Returns a FileContentResult, FilePathResult, or FileStreamResult depending on the parameters passed to the method.

So, if you want to return a View to the browser, you call the View() method. If you want to redirect the user from one controller action to another, you call the RedirectToAction() method.

For example, the Details() action in Listing 3 either displays a view or redirects the user to the Index() action depending on whether the Id parameter has a value.

Listing 3 - CourseController.cs

using System.Web.Mvc;
namespace FirstMvcApplication1.Controllers
{
public class CourseController : Controller
{
public ActionResult Details(int? id)
{
if (!id.HasValue)
return RedirectToAction("Index");
return View();
}
public ActionResult Index()
{
return View();
}
}

}

The ContentResult action result is special. You can use the ContentResult action result to return an action result as plain text.

For example, the Index() method in Listing 4 returns a message as plain text and not as HTML.

Listing 4 - Controllers\StatusController.cs

using System.Web.Mvc;
namespace FirstMvcApplication1.Controllers
{
public class StatusController : Controller
{
// GET: /Status/
public ActionResult Index()
{
return Content("Hello World!");
}
}
}

When the StatusController.Index() action is invoked, a view is not returned. Instead, the raw text "Hello World!" is returned to the browser.

If a controller action returns a result that is not an action result - for example, a date or an integer - then the result is wrapped in a ContentResult automatically. For example, when the Index() action of the WorkController in Listing 5 is invoked, the date is returned as a ContentResult automatically.

Listing 5 - WorkController.cs

using System;
using System.Web.Mvc;
namespace FirstMvcApplication1.Controllers
{
public class WorkController : Controller
{
// GET: /Work/
public DateTime Index()
{
return DateTime.Now;
}
}

}

The Index() action in Listing 5 returns a DateTime object. The ASP.NET MVC framework converts the DateTime object to a string and wraps the DateTime value in a ContentResult automatically. The browser receives the date and time as plain text.

how to create controller in mvc

2019-03-20T13:12:00.001+05:30

To remove the 404 Not Found error, we need to add a controller, which handles all the incoming requests.

Step 1 − To add a controller, right-click on the controller folder in the solution explorer and select Add → Controller.

Step 2 − Select the MVC 5 Controller – Empty option and click ‘Add’ button.

The Add Controller dialog will appear

Step 3 − Set the name to FirstMVCController and click the Add button.

You will see a new C# file FirstMVCController.cs in the Controllers folder, which is open for editing in Visual Studio as well.

Step 4 − To make this a working example, let’s modify the controller class by changing the action method called Index using the following code.

public class FirstMVCController : Controller

{ // GET: FirstMVC

public string Index() {

return "Hello World, this is ASP.Net MVC Tutorials";

} }

Step 5 − Run this application and you will see that the browser is displaying the result of the Index action method

Routing in mvc

2019-03-19T17:19:00.000+05:30

Basically, Routing in mvc is a pattern matching system that monitor the incoming request and figure out what to do with that request. At runtime, Routing engine use the Route table for matching the incoming request's URL pattern against the URL patterns defined in the Route table. You can register one or more URL patterns to the Route table at Application_Start event. MVC5 also supports attribute routing

How to define Routing in mvc ..

public static void RegisterRoutes(RouteCollection routes)

{

routes.MapRoute(

"Default", // Route name

"{controller}/{action}/{id}", // Route Pattern

new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Default values for above defined parameters

);

}

protected void Application_Start()

{

RegisterRoutes(RouteTable.Routes);

//To:DO

}

When the routing engine finds a match in the route table for the incoming request's URL, it forwards the request to the appropriate controller and action. If there is no match in the route table for the incoming request's URL, it returns a 404 HTTP status code.

Note

Always remember route name should be unique across the entire application. Route name can’t be duplicate.

How it works Routing ...

In above example we have defined the Route Pattern {controller}/{action}/{id} and also provide the default values for controller,action and id parameters. Default values means if you will not provide the values for controller or action or id defined in the pattern then these values will be serve by the routing system.

Suppose your webapplication is running on www.example.com then the url pattren for you application will be www.example.com/{controller}/{action}/{id}. Hence you need to provide the controller name followed by action name and id if it is required. If you will not provide any of the value then default values of these parameters will be provided by the routing system. Here is a list of URLs that match and don't match this route pattern.

Matching URLs

Request URL

Parameters

http://example.com/

controller=Home, action=Index, id=none, Since default value of controller and action are Home and Index respectively.

http://example.com/Admin

controller=Admin, action=Index, id=none, Since default value of action is Index

http://example.com/Admin/Product

controller=Admin, action=Product, id=none

http://example.com/Admin/Product/1

controller=Admin, action=Product, id=1

http://example.com/Admin/
Product/SubAdmin/1

No Match Found

http://example.com/Admin/
Product/SubAdmin/Add/1

No Match Found

Mvc life cycle

2019-03-18T22:54:00.000+05:30

In this chapter, we will discuss the overall MVC pipeline and the life of an HTTP request as it travels through the MVC framework in ASP.NET. At a high level, a life cycle is simply a series of steps or events used to handle some type of request or to change an application state. You may already be familiar with various framework life cycles, the concept is not unique to MVC.

For example, the ASP.NET webforms platform features a complex page life cycle. Other .NET platforms, like Windows phone apps, have their own application life cycles. One thing that is true for all these platforms regardless of the technology is that understanding the processing pipeline can help you better leverage the features available and MVC is no different.

MVC has two life cycles :

The application life cycle
The request life cycle

The Application Life Cycle

The application life cycle refers to the time at which the application process actually begins running IIS until the time it stops. This is marked by the application start and end events in the startup file of your application.

The Request Life Cycle

It is the sequence of events that happen every time an HTTP request is handled by our application.

The entry point for every MVC application begins with routing. After the ASP.NET platform has received a request, it figures out how it should be handled through the URL Routing Module.

Modules are .NET components that can hook into the application life cycle and add functionality. The routing module is responsible for matching the incoming URL to routes that we define in our application.

All routes have an associated route handler with them and this is the entry point to the MVC framework.

The MVC framework handles converting the route data into a concrete controller that can handle requests. After the controller has been created, the next major step is Action Execution. A component called the action invoker finds and selects an appropriate Action method to invoke the controller.

After our action result has been prepared, the next stage triggers, which is Result Execution. MVC separates declaring the result from executing the result. If the result is a view type, the View Engine will be called and it's responsible for finding and rending our view.

If the result is not a view, the action result will execute on its own. This Result Execution is what generates an actual response to the original HTTP request.

MVC Introduction

2019-03-15T14:00:00.002+05:30

Entity Framework Code-First

Learn Entity Framework Code-First in simple step-by-step tutorials. These tutorials cover all the features of Entity Framework Code-First starting with the basics of code-first, DB migration, configuring one-to-one, one-to-many and many-to-many relationships with DataAnnotation & Fluent API, and many other features.

Audience:

This tutorial is helpful for beginners who want to learn the Entity Framework Code-First approach from scratch.

Prerequisites:

Basic knowledge of .Net Framework, C#, Visual Studio, and MS SQL Server are required. Also, basic knowledge of Entity Framework would be advantageous.

ASP.NET MVC Folder Structure:

We have created our first MVC 5 application in the previous section. Visual Studio creates the following folder structure for MVC application by default.

Let's see significance of each folder.

App_Data:

App_Data folder can contain application data files like LocalDB, .mdf files, xml files and other data related files. IIS will never serve files from App_Data folder.

App_Start:

App_Start folder can contain class files which will be executed when the application starts. Typically, these would be config files like AuthConfig.cs, BundleConfig.cs, FilterConfig.cs, RouteConfig.cs etc. MVC 5 includes BundleConfig.cs, FilterConfig.cs and RouteConfig.cs by default. We will see significance of these files later.

Content:

Content folder contains static files like css files, images and icons files. MVC 5 application includes bootstrap.css, bootstrap.min.css and Site.css by default.

Controllers:

Controllers folder contains class files for the controllers. Controllers handles users' request and returns a response. MVC requires the name of all controller files to end with "Controller". You will learn about the controller in the next section.

fonts:

Fonts folder contains custom font files for your application.

Models:

Models folder contains model class files. Typically model class includes public properties, which will be used by application to hold and manipulate application data.

Scripts:

Scripts folder contains JavaScript or VBScript files for the application. MVC 5 includes javascript files for bootstrap, jquery 1.10 and modernizer by default.

Views:

Views folder contains html files for the application. Typically view file is a .cshtml file where you write html and C# or VB.NET code.

Views folder includes separate folder for each controllers. For example, all the .cshtml files, which will be rendered by HomeController will be in View > Home folder.

Shared folder under View folder contains all the views which will be shared among different controllers e.g. layout files.

Additionally, MVC project also includes following configuration files:

Global.asax:

Global.asax allows you to write code that runs in response to application level events, such as Application_BeginRequest, application_start, application_error, session_start, session_end etc.

Packages.config:

Packages.config file is managed by NuGet to keep track of what packages and versions you have installed in the application.

Web.config:

Web.config file contains application level configurations.

The MVC (Model-View-Controller) design pattern has actually been around for a few decades, and it's been used across many different technologies. Everything from Smalltalk to C++ to Java, and now C Sharp and .NET use this design pattern to build a user interface.

Following are some salient features of the MVC pattern −

Originally it was named Thing-Model-View-Editor in 1979, and then it was later simplified to Model- View-Controller.
It is a powerful and elegant means of separating concerns within an application (for example, separating data access logic from display logic) and applies itself extremely well to web applications.
Its explicit separation of concerns does add a small amount of extra complexity to an application’s design, but the extraordinary benefits outweigh the extra effort.

The MVC architectural pattern separates the user interface (UI) of an application into three main parts

The Model − A set of classes that describes the data you are working with as well as the business logic.

The View − Defines how the application’s UI will be displayed. It is a pure HTML, which decides how the UI is going to look like.

The Controller − A set of classes that handles communication from the user, overall application flow, and application-specific logic.

Idea Behind MVC

The idea is that you'll have a component called the view, which is solely responsible for rendering this user interface whether that be HTML or whether it actually be UI widgets on a desktop application.

The view talks to a model, and that model contains all of the data that the view needs to display. Views generally don't have much logic inside of them at all.

In a web application, the view might not have any code associated with it at all. It might just have HTML and then some expressions of where to take pieces of data from the model and plug them into the correct places inside the HTML template that you've built in the view.

The controller that organizes is everything. When an HTTP request arrives for an MVC application, that request gets routed to a controller, and then it's up to the controller to talk to either the database, the file system, or the model..

In this section, we will create a new MVC 5 application with Visual Studio 2013 for Web and understand the basic building blocks of a MVC Application.

First of all, setup a development environment to develop an ASP.NET MVC 5 application

Note : Basic tutorials use MVC 5.2. However, all the basic tutorials are applicable to the previous version aso such as MVC 3.0 & MVC 4.0.

Development Environment setup:

You can develop ASP.NET MVC application with appropriate version of Visual Studio and .NET framework, as you have seen in the previous section of version history.

Here, we will use MVC v5.2, Visual Studio 2013 for Web Express edition and .NET framework 4.5 to create MVC application.

Download and install Visual Studio Express 2013 for Web-update3. Please check the System requirements to install VS2013