MVC

Like in ASP.Net web forms, we have a toolbox for adding controls (like textbox, label, dropdown) on any particular page. Now, in the ASP.NET MVC application, there is no toolbox available to add controls on the view. ASP.NET MVC provides HtmlHelper class which contains various methods that help you create HTML controls programmatically. All HtmlHelper methods generate HTML and return the result as a string. The final HTML is generated at runtime by these functions. The HtmlHelper class is designed to generate UI and it should not be used in controllers or models.

The following is the list of Html Helper controls.

Html.Beginform

Html.EndForm

Html.Label

Html.TextBox

Html.TextArea

Html.Password

Html.DropDownList

Html.CheckBox

Html.RedioButton

Html.ListBox

Html.Hidden

Below are Strongly Type Html Helper methods, this will allow us to check compile-time errors. 

We get Model's Property intelligence at Runtime.

Html.LabelFor

Html.TextBoxFor

Html.TextAreaFor

Html.DropDownListFor

Html.CheckBoxFor

Html.RadioButtonFor

Html.ListBoxFo

Output Caching is part of state management. Output Caching is one of the types of Action Filter. Output caching can help to improve the performance of MVC application by caching the content returned by any controller action. It reduces the server and database round trips and also reduces network traffic.

Enabling Output Caching

Output Caching can be enabled by adding attribute: [OutputCache] to either on controller or action method. If added to the top of the controller then output caching is enabled for all the action methods of that controller.

Example:

public class HomeController : Controller
{
    [OutputCache(Duration=10, VaryByParam="none")]
    public ActionResult Index()
    {
       return View();
    }
}

Where the content is Cached

By default, the content is cached in three locations: web server, proxy server, and web browser. But we can control where exactly we want to cache the content by modifying the location property of [OutputCache].

Example:

[OutputCache(Duration=3600, VaryByParam="none", Location=OutputCacheLocation.Client)]
 public ActionResult Index()
    {
       return View();
    }

Any of the value for Location property can be selected as follows:

• Any (this is the default value selected)
• Client
• Downstream
• Server
• None
• ServerAndClient

Creating a Cache Profile

MVC has provided one more feature to create a caching profile. Creating a caching profile on a configuration file (web.config) provides a couple of advantages like:

1. Manage how controller action cache the content. We can create one cache profile and apply it to several controller and controller actions.
2. Modify the cache configuration without recompiling the application

Example:

<caching>
<outputCacheSettings>
    <outputCacheProfiles>
        <add name="Cache1HourTest" duration="3600" varyByParam="none" Location=OutputCacheLocation.Any/>
    </outputCacheProfiles>
</outputCacheSettings>
</caching>

Html.HiddenFor

HtmlHelper class generates html elements. For example, @Html.ActionLink("Create New", "Create") would generate anchor tag <a href="/Student/Create">Create New</a>.

Partial view is a reusable view like the user control in ASP.NET, which can be used as a child view in multiple other views. It reduces the duplicate code in the system by reusing the same partial view in multiple views. You can use the partial view in the layout view, as well as other content views.

To render the partial view in the parent view we use  HTML helper methods: Partial() or RenderPartial() or RenderAction(). Each method has different purposes, as follows:

• The partial helper method renders the given partial view. It accepts partial view name as a string parameter and returns MvcHtmlString. 
• RenderPartial helper method is like the Partial method but it returns void and writes resulted in HTML of a specified partial view into an http response stream directly.
• RenderAction helper method invokes a specified controller and action and renders the result as a partial view. 

The majority of the websites are making use of Javascript and CSS files to improve the usability and look and feel of websites. So often on these pages, you will find multiple <script> and <link> tags. Each time the browser runs across these tags, make the call to the server to download the respective script and CSS files.  

So the number of Javascript and CSS files in our application, more the requests made to the server which leads to increase the time to load the page and make it functional.

In MVC 4.5 two new techniques are introduced to reduce these requests and improve the request load time. These two techniques are:

1. Bundling
2. Minification

Bundling

As the name says, Bundling combines the multiple files of the same type into a single file. So like if we have multiple script files use in an application, Bundling will combine all these script files into one single script file. Since the number of files is reduced, hence the number of HTTP requests is also reduced and this can improve first-page load performance.

In MVC Application there is a file called BundleConfig.cs in App_Start folder where we can add similar files into one bundle. We can add/register multiple bundles here.

Minification

Minification technique helps to reduce the size of the files. This technique applies to the bundled files. It applies various code optimizations to scripts and CSS like reducing/removing unnecessary white spaces and comments, shortening variable names.

We can enable/disable Bundling and minification through Web.config file as: 

<system.web>
<compilation debug="true" />
<!-- Lines removed for clarity. -->
</system.web>

ASP.NET Scaffolding is a code generation framework for ASP.NET Web applications. Scaffolding quickly adds code that interacts with data models and reduces the amount of time to develop standard data operations in the project. With the help of scaffolding, we can add views of Index, Create, Edit actions very easily and the code is itself added for each view and action methods.

Scaffolding consists of Scaffold templates like page templates, entity page templates, field page templates, and filter templates. These templates allow to quickly build a functional data-driven Website. They are used to generate code for basic CRUD operations against the database with the help Entity Framework. These templates the Visual Studio T4 templating system to generate views for basic CRUD operations with the help of Entity Framework

Below are the options in AJAX helpers –

• Url: This is the request URL.
• Confirm: This is used to specify the message which is to be displayed in the confirm box.
• OnBegin:  method name to be given here and this will be called before the AJAX request.
• OnComplete:  method name to be given here and this will be called at the end of AJAX request.
• OnSuccess: method name to be given here and this will be called when AJAX request is successful.
• OnFailure: method name to be given here and this will be called when AJAX request is failed.
• UpdateTargetId: Target element which is populated from the action returning HTML.

Authentication is to give access to the user for a specific service by verifying his/her identity using his/her credentials like username and password. 

After IIS authentication, ASP.NET form authentication occurs. We can configure forms authentication by using forms element in web.config. The default attribute values for forms authentication are shown below,

<system.web>  
    <authenticationmode="Forms">  
        <formsloginUrl="Login.aspx" protection="All" timeout="30" name=".ASPXAUTH" path="/" requireSSL="false" slidingExpiration="true" defaultUrl="default.aspx" cookieless="UseDeviceProfile" enableCrossAppRedirects="false" />  
        </authentication>  
</system.web>  

The FormsAuthentication class creates the authentication cookie automatically when SetAuthCookie() or RedirectFromLoginPage() methods are called. The value of an authentication cookie contains a string representation of the encrypted and signed FormsAuthenticationTicket object.

Validation Summary is used to display the list error messages of a page at fixed one place. If it summarises all the error messages of a page and shows them at once after the submit button is clicked and page is validated. 

MVC have provided the helper class display a summary of all validation errors of a page as:

@Html.ValidationSummary

To display validation summary we need to add this helper class in our view as:

@Html.ValidationSummary(false, "", new { @class = "text-danger" })

We can also display the custom error message using ValidationSummary. For this, we need to add the custom error messages to the ModelState in the respective action method.

Example:

if (ModelState.IsValid) { 
    bool nameExists = * check here *       
    if(nameExists)
    {
        ModelState.AddModelError(string.Empty, "Name already exists.");    
        return View(name);
    }}

A staple in Spring MVC interview questions with answers, be prepared to answer this one using your hands-on experience. This is also one of the top interview questions to ask an MVC.

RenderSection is used to designate a place to render content that is different from the one in RenderBody.

Example:

@RenderSection("footer", required: false)

By default, a section is required. We pass required: false to designate that section is optional.

@Section is used to render section in View as:

@section Footer

{
    <p>Section/Index page</p>
}

The high-level flow of the request with the following diagram:

When the request is made by any client then at first it goes to the URL Routing, where the URL is compared to the routes that are present in the routing table. This helps to identify the controller and action method name.

Based on the identified controller action method is called by passing the required parameters (if any).

From where Model is called that interacts with Database to get the required response and returns to the controller action method.

The action method parses the response in the requested Action result format and returns back to View to present to the client.

Html.RenderPartial is directly written to the HTTP response stream which is used the same Text Writer object as used in the current webpage/template. Since there is no return type of Validation Annotations in MVC, the return type of Validation Annotations is void. We don't need to create any actions so it is simple to use, it is very useful when we want to show the data which is in another model view.

For example: if we want to show comments of an article, we will prefer to use RenderPartial method since the information and comments of the article are already populated in the view model.

@{Html.RenderPartial("_Comments");}

When it is executed its result is directly written to the response stream which makes it faster when compared with the partial method

In Html.Partial, the partial view is viewed as an encoded HTML string. Due to its string value return type, we can store the Html.Partial value in a variable.it same as Html.RenderPartial in case of action creation also,  we don’t need to create action, Partial method is also useful when the displaying data in the partial view is already in the corresponding view model which same as html.RenderPartial.

@Html.Partial("_Comments")

when we want a certain code to be used at some other view, we use a partial view. In simple words we can say that  it is a child view which can be used in some other views, it prevents the duplicate of code since it used the same partial view at some other places

When we want a partial view to be used on multiple controllers then we need to create a shared folder in the solution, otherwise, if it using in a single controller then it doesn`t need it. Using Partial() or RenderPartial() or RenderAction() helper method .we can render the partial view content in its parent view

@Html.Partial() helper method renders the specified partial view. It returns HTML string so we have a chance of modifying the HTML before rendering.

The different types of overloads used in partial views are:

1. MvcHtmlString Html.Partial(string partialViewName)
2. MvcHtmlString Html.Partial(string partialViewName,object model)
3. MvcHtmlString Html.Partial(string partialViewName, ViewDataDictionary viewData)
4. MvcHtmlString Html.Partial(string partialViewName,object model, ViewDataDictionary viewData)

• MvcHtmlString Html.Partial(string partialViewName): it Renders the given partial view content in the referred view.
• MvcHtmlString Html.Partial(string partialViewName, object model): in this, the modal passes its parameter into the partial view and render the view which is referred to it.
• MvcHtmlString Html.Partial(string partialViewName, ViewDataDictionary viewData): it passes the view data dictionary to the partial view and render the partial view content in the preferred view.
• MvcHtmlString Html.Partial(string partialViewName, object model, ViewDataDictionary viewData): when we want to pass the model object and view data dictionary to the partial view, and render the partial view content in the referred view.

when we want to improve the performance of the application we use output caching, it prevents the duplicate content to be loaded by caching the content returned by the controller,  when the controller methods are invoked, it is the best method to reduce the server round trips, reduces database server round trips, reduces network traffic etc.

Let’s Suppose when we want to display the list of records from the database in the view , so every time when the user invokes the controller method the query will be executed which will reduce the performance of the application, So, we can advantage of the "Output Caching" that avoids executing database queries each time the user invokes the controller method.

It is not necessary that the data will be retrieved until the time we have given, When memory resources become low, the cache starts evicting content automatically, and thus increase the performance of the Project.

The duration is in seconds by default the value used is 60 seconds

[HttpPost]  
   [OutputCache(Duration = 10, VaryByParam = "name")]  
   public ActionResult SearchCustomer(string name = "")  
   {
       NorthwindEntities db = new NorthwindEntities();  
       var model = from r in db.Customers  
                   where r.ContactName.Contains(name)  
                   select r;
       if (model.Count() > 0)  
       {
           return View(model);  
       }
       else
       {
           return View();  
       }
   }

In the above code the "name" parameter passed by the user and then, depending on the name, selecting matching records with a LINQ query and then checking if the model has the number of records greater than zero then send the model to the view else simply send the view (no model),VaryByParam="name" and "VeryByParam" is something that makes many differences

1.VaryByParam = "none": Think of it like, we don't want to care about the form parameter or query string parameter passed by the user from the view page. If I use "none" then it will create the same cached version of the content for every user who visits the website,

2.VaryByParam = "name": By using this we can create different cached versions of the content when the query string parameter is varied from one param to other. In other words if I find records matching "ce" string then a new cache will be created by replacing the older one, again if I find records matching "ab" string then a new cache will be created by replacing the last one ("ce" cached), no matter duration is elapsed or not.

Bundling and Modification is used to improve the request load time, In this, we can store many static files from the server in a single request, It is created in BundleConfig.cs in the App_Start folder, This file is creating Bundles by associating multiple files to routes. For example, the "~/bundles/bootstrap" route will correspond to both the bootstrap.js file and the respond.js file, and the browser will only need one HTTP request to retrieve both files

Eg.

using System. Web;
using System.Web.Optimization;

namespace BundlingExample
{
   public class BundleConfig
   {
       public static void RegisterBundles(BundleCollection bundles)
       {
           bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
                       "~/Scripts/jquery-{version}.js"));

           bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
                       "~/Scripts/modernizr-*"));

           bundles.Add(new ScriptBundle("~/bundles/bootstrap").Include(
                     "~/Scripts/bootstrap.js",
                     "~/Scripts/respond.js"));

           bundles.Add(new StyleBundle("~/Content/css").Include(
                     "~/Content/bootstrap.css",
                     "~/Content/site.css"));

           BundleTable.EnableOptimizations = false;
       }
   }
}

• Minification : Minification is used to remove the white space, text, short comments from the files such as JavaScript and CSS files without expecting to alter functionality to reduce the size, which causes improved load times of a Webpage.

Eg.

sayHello = function(name)
{ //this is comment
var msg = "Hello" + name; alert(msg);
}
Minified Javascript is
sayHello=function(n){var t="Hello"+n;alert(t)}

it has removed unnecessary white space, comments and also shortening variable names to reduce the characters which in turn will reduce the size of JavaScript file., It increases the loading effects of a page by minimizing the number of request and size of the files.

There are different types of bundles used in MVC which is defined under the System.web.Optimization namespace

• ScriptBundle: ScriptBundle is responsible for JavaScript minification of single or multiple script files.
• StyleBundle: StyleBundle is responsible for CSS minification of single or multiple style sheet files.

DynamicFolderBundle: it represents a Bundle object that ASP.NET creates from a folder that contains files of the same type.

Bundling and Minification It Reduces the request and size of the js and css resource file and thereby improving the responsiveness of our apps.

Don't be surprised if this question pops up as one of the top MVC interview questions and answers for experienced professionals in your next interview.

MVC have separate folders for Model, View and Controller. In the case of large projects, it becomes unmanageable with the default MVC structure. MVC 2 has introduced Area.
The area allows partitioning of large applications into smaller units, where each unit contains a separate folder structure, which is as the default MVC structure.
For  Example, Large applications may have different modules like admin, HR etc. So Area can contain separate MVC folder structure for each module.

Create MVC Area

To add MVC Area into your application, follow the below steps:

1. Right-click to project solution explorer -> Add -> Area
2. Enter the name of the area in the dialogue box and click Add button
3. An area with a given name gets added with separate MVC folder structure.

When we want to use a code for pre-installed web API and MVC, we use scaffolding  .it is a quite quick process which interacts with the data model. The main use of adding scaffolding is to interact with code and data model fast. It reduces the amount of time to develop standard data operations in your project.

Scaffold templates are used to generate code for basic CRUD operations and writes a method specific to each DML operation against your database with the help Entity Framework. For this, they use Visual Studio T4 templating system to generate views.

Let's understand it with an example.

Let's create a simple class by the name of Employee.cs.

Add some properties to Employee class using the following code

using System;

namespace MVCScaffoldingDemo.Models {
  public class Employee{
     public int ID { get; set; }
     public string Name { get; set; }
     public DateTime JoiningDate { get; set; }
     public int Age { get; set; }
  }
}

We need to add another class, which will communicate with Entity Framework to retrieve and save the data.

using System;
using System.Data.Entity;

namespace MVCScaffoldingDemo.Models{
  public class Employee{
     public int ID { get; set; }
     public string Name { get; set; }
     public DateTime JoiningDate { get; set; }
     public int Age { get; set; }
  }

  public class EmpDBContext : DbContext{
     public DbSet<Employee> Employees { get; set; }
  }
}

As we know that EmpDBContext which is derived from the DB.Context class, In this class, we have one property with the name DbSet, which basically represents the entity which you want to query and save.

Validation Summary is used to visualise the error message in the unordered list which is in ModelStateDictionary object.we can display the validation error of each property which is defined under modal

ValidationSummary() Signature

MvcHtmlString ValidateMessage(bool excludePropertyErrors, string message, Object htmlAttributes)

If we want to show error message summary of the field which is defined under the modal then specify excludePropertyErrors = false.

To display field error in the validation summary

Syntax is @Html.ValidationSummary(false, "", new { @class = "text-danger" })

We can also display a custom error message using ValidationSummary. If Student name exists in the database then it will display the message.

To display a custom error message, first of all, you need to add custom errors into the ModelState in the appropriate action method.

Eg.

if (ModelState.IsValid)
{
bool nameAlreadyExists = * check database *
if(nameAlreadyExists)
{
ModelState.AddModelError(string.Empty,
"Student Name already exists.");
return View(std);
}
}

In this Validation Summary will automatically generate the error message into the modal state

we have to add the custom error messages using the ModelState.AddModelError method

The Different Validation overloading methods are :

• ValidationSummary(HtmlHelper, Boolean, String, Object): It Returns an unordered list of validation messages that are in the modelstatedictionary object and optionally displays only model-level errors.
• ValidationSummary(HtmlHelper, Boolean, String, IDictionary<String,Object>): it will worked same as the ValidationSummary(HtmlHelper, Boolean, String, Object).
• ValidationSummary(HtmlHelper, String, Object)
• ValidationSummary(HtmlHelper, String, IDictionary<String,Object>)
• ValidationSummary(HtmlHelper, Boolean, String)
• ValidationSummary(HtmlHelper, String)
• ValidationSummary(HtmlHelper, Boolean)
• ValidationSummary(HtmlHelper)

Application life cycle is simply a series of steps or events used to handle some type of request or to change an application state.it uses the HTTP as a protocol to send the request on the browser, 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.

There are 2 different life cycle used in Asp.Net MVC:-

1. Application Life Cycle
2. Request Life Cycle

Application life cycle helps in getting to know that IIS will start working till its time will stop.

First, the request will find the routing method which is defined under the RouteConfig.cs, where there is a controller and its action method, is defined in the URL, after the controller has been created,actually begins running IIS until the time it stops,A component called the action invoker finds and selects an appropriate Action method to invoke the controller,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 rendering our view, If the result is not a view, the action result will execute on its own. It displays the actual HTTP result during the execution of the request.

This is a common yet one of the most important ASP.NET MVC interview questions and answers for experienced professionals, don't miss this one.

To make the development easy and simple as compared to asp.net web form application we use attribute routing, it is one of the different method which works differently routing

We used to define the routing in either Global.asax and RouteConfig.cs where this will decide which URL has to be chosen for the development

We need to put routes.MapMvcAttributeRoutes() in the routeconfig.cs which  enable attribute based routing on our MVC web application that can be done by only one line

Eg.

public static void RegisterRoutes(RouteCollection routes)

{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.MapMvcAttributeRoutes();
routes.MapRoute(  
name: "Default",  
url: "{controller}/{action}/{id}",
defaults: new { controller = "Product", action = "List", id =      UrlParameter.Optional }
);
}
In an action method, it is used like this
Eg.
[Route("products/{id?}")]
public ActionResult Details(string id)   
{
if (string.IsNullOrEmpty(id))
{
return View("List", GetProductList());
}
return View("Details", GetProductDetails());
}

Route Prefixes

We put the Route Prefix inside the controller which the request follow the route which is defined under the controller in the action method

Eg.

[RoutePrefix("products")]
public class ProductController : Controller
{
[Route]
public ActionResult List()
{
return View();
}
[Route("{id?}")]
public ActionResult Details(string id)
{
if (string.IsNullOrEmpty(id))  
{
return View("List");  
}
return View("Details");  
}
}

MVC routing uses the route table to look up and call the desired controller method, which renders the respected view. We can provide the routes in routeconfig file.

Sometimes it is required to have routes that are different from the ones configured in routeconfig and is specific to any controller or controller action method. In this attribute, routing comes into the picture.

To enable attribute based routing to add below line to routeconfig file under RegisterRoutes methods.

routes.MapMvcAttributeRoutes();

Samples of attribute routing:

1. [Route(“products/{id?}”)]

This route is to get a product with a given id. If id not provided then return all products

2. [RoutePrefix(“products”)]

This is places over the controller. All routes that start with products come to here

3. [RouteArea(“business”)]

RouteArea is a way to specify are in the route. It is just to let the route know that controller belongs to some area.