Exception handling in ASP.

NET MVC (6 methods explained)

Introduction

Method 1:- Simple way

Method 2:- Override “OnException” method

Method 3:- Using “HandleError” Attribute

Method 4:- Inheriting from “HandleErrorAttribute”

Method 5:- Handling HTTP errors

Method 6:- Global Error handling in MVC

What’s the best practice ?

Further reading

Exception handling in ASP.NET MVC (6

methods explained)
Introduction
In this Asp.net MVC step by step article we have discuss 6 ways of handling exceptions in
ASP.NET MVC.In this article we also talk about best practices of MVC exception handling.

Method 1:- Simple way

The simplestwayis to use the traditional .NET exception handling style i.e. try and catch block.
Now when exception happens catch block gets executed and it redirects to the error view.

But if we use this method then we will not be utilizing MVC exception mechanismproperly and
completely. In the further sections we will discuss five important ways by which we can utilize
MVC provided features for exception handling.

Hide Copy Code

public ActionResult SomeError()

{
try
{}
catch(Exception ex)
{return View("Error");}
}
Method 2:- Override “OnException” method
In this method we can override the “OnException” event of the controller and set the “Result” to
the view name. This view gets invoked when error occurs in this controller. In the below code you
can see we have set the “Result” to a view named as “Error”.

We have also set the exception so that it can be displayed inside the view.

Hide Copy Code

public class HomeController : Controller

{
protected override void OnException(ExceptionContext filterContext)
{
Exception ex = filterContext.Exception;
filterContext.ExceptionHandled = true;

var model = new HandleErrorInfo(filterContext.Exception,

"Controller","Action");

filterContext.Result = new ViewResult()

{
ViewName = "Error",
ViewData = new ViewDataDictionary(model)
};

}
}

To display the above error in view we can use the below code:-

Hide Copy Code

@Model.Exception;

The problem with this approach is we cannot reuse the error handling logic across multiple
controllers.

Method 3:- Using “HandleError” Attribute

The other way of handling error is my using “HandleError” attribute. Implementing “HandleError”
attribute is a two-step process:-

Step 1 :- We need to first decorate the action method with “HandleError” attribute as shown in
the below code.

Hide Copy Code

public class HomeController : Controller
{
[HandleError()]
public ActionResult SomeError()
{
 throw new Exception("test");
}
}

Step 2:- In the “Web.config” file you need to add the “customErrors” tag and point to the “Error”
view as shown in the below “Web.config” code snippet.

Hide Copy Code

<system.web>
<customErrors defaultRedirect="Error.cshtml" mode="On">
</customErrors>
</system.web>

In case you want different error views for different exception types you can decorate action
method with multiple “HandleError” attribute point to multiple views as per exception types.

Hide Copy Code

public class HomeController : Controller
{
[HandleError(ExceptionType=typeof(ArithmeticException),View="Arthimetic")]
[HandleError(ExceptionType = typeof(NotImplementedException),View ="Error1")]
public ActionResult SomeError()
{

}
}

Method 4:- Inheriting from “HandleErrorAttribute”

One of the biggest drawbacks of all the previous method was reusability. Error handling logic
cannot be reused across other controllers.

In order to reuse error handling logic across controller we can inherit from
“HandleErrorAttribute”class anddecorate this class as attribute across controller.

Hide Copy Code

public class Err : HandleErrorAttribute

{
public override void OnException(ExceptionContext filterContext)
{
Exception ex = filterContext.Exception;
filterContext.ExceptionHandled = true;
var model = new HandleErrorInfo(filterContext.Exception, "Controller", "Action");

filterContext.Result = new ViewResult()

{
ViewName = "Error1",
ViewData = new ViewDataDictionary(model)
};
}
}
Method 5:- Handling HTTP errors
All MVC exception handling techniques discussed till now do not handle HTTP errors like file not
found, HTTP 500 error’s etc. For that we need to make an entry of the error action and the error
status code as shown in the below config file.

Hide Copy Code

<system.web>
<customErrors
mode="On" defaultRedirect="Error1">
<error statusCode="404" redirect="~/Testing/NoPageFound"/>
</customErrors>
</system.web>

Method 6:- Global Error handling in MVC

If you wish to do global error handling across your application you can override the
“Application_Error” event and do a response.redirect from the global error event. So if the error
handling is not done at the controller level it will get propagated to “Global.asax” file.

Hide Copy Code

public class MvcApplication : System.Web.HttpApplication
{
protected void Application_Error(object sender, EventArgs e)
{
Exception exception = Server.GetLastError();
Server.ClearError();
Response.Redirect("/Home/Error");
}
}

1. What is MVC (Model View Controller)

MVC is a software architecture pattern for developing web application. It is handled by

three objects Model-View-Controller. Below is how each one of them handles the task.

 Model- It represents the application data domain. In other words

applications business logic is contained within the model and is
responsible for maintaining data
 View- It represents the user interface, with which the end users
communicates. In short all the user interface logic is contained within
the VIEW
 Controller- It is the controller that answers to user actions. Based on the
user actions, the respective controller responds within the model and
choose a view to render that display the user interface. The user input
logic is contained with-in the controller
he View is responsible for the look and feel.

2. What is MVC Application Life Cycle

Any web application has two main execution steps first understanding the request and
depending on the type of the request sending out the appropriate response. MVC
application life cycle is not different it has two main phases first creating the request
object and second sending our response to the browser.
Creating the request object: -The request object creation has four major steps. Below is
the detail explanation.

Step 1 Fill route: MVC requests are mapped to route tables which in turn specify which
controller and action to be invoked. So if the request is the first request the first thing is
to fill the route table with routes collection. This filling of route table happens in the
global.asax file.
Step 2 Fetch route: Depending on the URL sent “UrlRoutingModule” searches the
route table to create “RouteData” object which has the details of which controller and
action to invoke.
Step 3 Request context created: The “RouteData” object is used to create the
“RequestContext” object.
Step 4 Controller instance created: This request object is sent to “MvcHandler”
instance to create the controller class instance. Once the controller class object is
created it calls the “Execute” method of the controller class.
Step 5 Creating Response object: This phase has two steps executing the action and
finally sending the response as a result to the view.

3. Explain in which assembly is the MVC framework is defined?

The MVC framework is defined in System.Web.Mvc.

 4. What are the advantages of MVC

A main advantage of MVC is separation of concern. Separation of concern

means we divide the application Model, Control and View.

We can easily maintain our application because of separation of concern.

In the same time we can split many developers work at a time. It will not affects
one developer work to another developer work.

It supports TTD (test-driven development). We can create an application with unit

test. We can write won test case.

Latest version of MVC Support default responsive web site and mobile templates.

5. List out different return types of a controller action method?

There are total nine return types we can use to return results from controller to view.
ViewResult (View): This return type is used to return a webpage from an action method.
PartialviewResult (Partialview): This return type is used to send a part of a view which
will be rendered in another view.
RedirectResult (Redirect): This return type is used to redirect to any other controller
and action method depending on the URL.
RedirectToRouteResult (RedirectToAction, RedirectToRoute): This return type is used
when we want to redirect to any other action method.
ContentResult (Content): This return type is used to return HTTP content type like
text/plain as the result of the action.
jsonResult (json): This return type is used when we want to return a JSON message.
javascriptResult (javascript): This return type is used to return JavaScript code that will
run in browser.
FileResult (File): This return type is used to send binary output in response.
EmptyResult: This return type is used to return nothing (void) in the result.

What is the difference between each version of MVC 2, 3 , 4, 5 and 6?

MVC 6
ASP.NET MVC and Web API has been merged in to one.
Side by side - deploy the runtime and framework with your application
No need to recompile for every change. Just hit save and refresh the browser.
Dependency injection is inbuilt and part of MVC.
Everything packaged with NuGet, Including the .NET runtime itself.
New JSON based project structure.
Compilation done with the new Roslyn real-time compiler.

MVC 5
Asp.Net Identity
Attribute based routing
Bootstrap in the MVC template
Filter overrides
Authentication Filters

MVC 4
ASP.NET Web API
New mobile project template
Refreshed and modernized default project templates
Many new features to support mobile apps

MVC 3
Razor
HTML 5 enabled templates
JavaScript and Ajax
Support for Multiple View Engines
Model Validation Improvements

MVC 2
Templated Helpers
Client-Side Validation
Areas
Asynchronous Controllers
Html.ValidationSummary Helper Method
DefaultValueAttribute in Action-Method Parameters
Binding Binary Data with Model Binders
DataAnnotations Attributes
Model-Validator Providers
New RequireHttpsAttribute Action Filter
 7. What are Filters in MVC?

Types of Filters:

ASP.NET MVC framework supports the following action filters:

Action Filters: Action filters are used to implement logic that gets executed before and
after a controller action executes.
Authorization Filters: Authorization filters are used to implement authentication and
authorization for controller actions.
Result Filters: Result filters contain logic that is executed before and after a view result
is executed. For example, you might want to modify a view result right before the view is
rendered to the browser.
Exception Filters: You can use an exception filter to handle errors raised by either your
controller actions or controller action results. You can also use exception filters to log
errors.

8. What are Action Filters in MVC?

Action Filters are additional attributes that can be applied to either a controller section or
the entire controller to modify the way in which action is executed. These attributes are
special .NET classes derived from System.Attribute which can be attached to classes,
methods, properties and fields.

ASP.NET MVC provides the following action filters:

Output Cache: This action filter caches the output of a controller action for a specified
amount of time.
Handle Error: This action filter handles errors raised when a controller action executes.
Authorize: This action filter enables you to restrict access to a particular user or role.

Output Cache
E.g.: Specifies the return value to be cached for 10 seconds.
publicclassActionFilterDemoController: Controller

{ [HttpGet]

OutputCache(Duration = 10)]

publicstringIndex()
{ returnDateTime.Now.ToString("T");

9. What are HTML helpers in MVC?

HTML helpers help you to render HTML controls in the view. For instance if you want to
display a HTML textbox on the view , below is the HTML helper code.
<%= Html.TextBox("FirstName") %>

For checkbox below is the HTML helper code. In this way we have HTML helper
methods for every HTML control that exists.
<%= Html.CheckBox("Yes") %>

The Html.ActionLink() helper has several properties:

Property Description.
.linkText The link text (label).
.actionName The target action.
.routeValues The values passed to the action.
.controllerName The target controller.
.htmlAttributes The set of attributes to the link.
.protocol The link protocol.
.hostname The host name for the link.
.fragment The anchor target for the link.
HTML Form Elements

There following HTML helpers can be used to render (modify and output) HTML form
elements:
BeginForm()
EndForm()
TextArea()
TextBox()
CheckBox()
RadioButton()
ListBox()
DropDownList()
Hidden()
Password()

10. What is the difference between “HTML.TextBox” and “HTML.TextBoxFor”?

Both provide the same HTML output, “HTML.TextBoxFor” is strongly typed while
“HTML.TextBox” isn’t. Below is a simple HTML code which just creates a simple
textbox with “FirstName” as name.
Html.TextBox("FirstName ")

Below is “Html.TextBoxFor” code which creates HTML textbox using the property name
‘FirstName” from object “m”.
Html.TextBoxFor(m => m.CustomerCode)

In the same way, we have for other HTML controls like for checkbox we have
“Html.CheckBox” and “Html.CheckBoxFor”.

11. What is Route in MVC? What is Default Route in MVC?

A route is a URL pattern that is mapped to a handler. The handler can be a physical file,
such as a .aspx file in a Web Forms application. A handler can also be a class that
processes the request, such as a controller in an MVC application. To define a route,
you create an instance of the Route class by specifying the URL pattern, the handler,
and optionally a name for the route.
You add the route to the application by adding the Route object to the static Routes
property of the RouteTable class. The Routesproperty is a RouteCollection object that
stores all the routes for the application.
You typically do not have to write code to add routes in an MVC application. Visual
Studio project templates for MVC include preconfigured URL routes. These are defined
in the Mvc Application class, which is defined in the Global.asax file.

Route definition Example of matching URL

{controller}/{action}/{id} /Products/show/beverages
{table}/Details.aspx /Products/Details.aspx
blog/{action}/{entry} /blog/show/123
{reporttype}/{year}/{month}/{day} /sales/2008/1/5
{locale}/{action} /US/show
{language}-{country}/{action} /en-US/show
Default Route
The default ASP.NET MVC project templates add a generic route that uses the following
URL convention to break the URL for a given request into three named segments.
URL: "{controller}/{action}/{id}"
This route pattern is registered via call to the MapRoute() extension method of
RouteCollection.

12. Where is the route mapping code written?

The route mapping code is written in "RouteConfig.cs" file and registered using
"global.asax" application start event.

13. What is the difference between Temp data, View, and View Bag?

ViewData

ViewData is used to pass data from controller to view.

It is derived from ViewDataDictionary class.

It is available for the current request only.

Requires typecasting for complex data type and checks for null values to avoid
error.

If redirection occurs, then its value becomes null.

ViewBag
 ViewBag is also used to pass data from the controller to the respective view.

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

It is also available for the current request only.

If redirection occurs, then its value becomes null.

Doesn’t require typecasting for complex data type.

1. public ActionResult StudentSummary()

2. {
3. var student = new Student()
4. {
5. Name = "Sandeep Singh Shekhawat",
6. Age = 24,
7. City = "Jaipur"
8. };
9. ViewBag.Student = student;
10. return View();
11. }

Difference between ViewBag&ViewData?

 ViewData is a dictionary of objects that is derived from ViewDataDictionary

class and accessible using strings as keys.
 ViewBag is a dynamic property that takes advantage of the new dynamic
features in C# 4.0.
 ViewData requires typecasting for complex data type and check for null
values to avoid error.
 ViewBag doesn't require typecasting for complex data type.
 Calling of ViewBag is:

ViewBag.Name = "Yogesh";
Calling of ViewDatais :
ViewData["Name"] = "yogesh";

TempData

TempData is derived from TempDataDictionary class

TempData is used to pass data from the current request to the next request
 It keeps the information for the time of an HTTP Request. This means only from
one page to another. It helps to maintain the data when we move from one
controller to another controller or from one action to another action

It requires typecasting for complex data type and checks for null values to avoid
error. Generally, it is used to store only one time messages like the error
messages and validation messages

TempDataDictionary is inherited from the IDictionary<string, object>,

ICollection<KeyValuePair<string, object>>, IEnumerable<KeyValuePair<string,
object>> and IEnumerable interfaces.

Example

1. public ActionResult FirstRequest()

2. {
3. List < string > TempDataTest = new List < string > ();
4. TempDataTest.Add("Tejas");
5. TempDataTest.Add("Jignesh");
6. TempDataTest.Add("Rakesh");
7. TempData["EmpName"] = TempDataTest;
8. return View();
9. }
10. public ActionResult ConsecutiveRequest()
11. {
12. List < string > modelData = TempData["EmpName"] as Li
st < string > ;
13. TempData.Keep();
14. return View(modelData);
15. }

14. What is Partial View in MVC?

 Partial view is a reusable view (like a user control) which can be embedded inside other
view. For example let’s say all your pages of your site have a standard structure with left
menu, header, and footer as shown in the image below.

For every page you would like to reuse the left menu, header, and footer controls. So
you can go and create partial views for each of these items and then you call that partial
view in the main view.

15. How did you create a partial view and consume it?

When you add a view to your project you need to check the “Create partial view” check
box.
Figure: Create partial view

Once the partial view is created you can then call the partial view in the main view using
the Html.RenderPartial method as shown in the below code snippet:
<body>

<div>

<% Html.RenderPartial("MyView"); %>

</div>

</body>

16. Explain what is the difference between View and Partial View?

View:
It contains the layout page.
Before any view is rendered, viewstart page is rendered.
View might have markup tags like body, html, head, title, meta etc.
View is not lightweight as compare to Partial View.

Partial View:
It does not contain the layout page.
Partial view does not verify for a viewstart.cshtml.We cannot put common code for a
partial view within the viewStart.cshtml.page.
Partial view is designed specially to render within the view and just because of that it
does not consist any mark up.
We can pass a regular view to the RenderPartial method.

17. Explain attribute based routing in MVC?

In ASP.NET MVC 5.0 we have a new attribute route, By using the "Route" attribute we
can define the URL structure. For example in the below code we have decorated the
"GotoAbout" action with the route attribute. The route attribute says that the "GotoAbout"
can be invoked using the URL structure "Users/about".

public class HomeController: Controller

[Route("Users/about")]

publicActionResultGotoAbout()

return View();

18. What is Razor in MVC?

Razor is not a new programming language itself, but uses C# syntax for embedding
code in a page without the ASP.NET delimiters: <%= %>. It is a simple-syntax view
engine and was released as part of ASP.NET MVC 3. The Razor file extension is
"cshtml" for the C# language. It supports TDD (Test Driven Development) because it
does not depend on the System.Web.UI.Page class.

19. How to implement Forms authentication in MVC?

Authentication is giving access to the user for a specific service by verifying his/her identity
using his/her credentials like username and password or email and password. It assures that
the correct user is authenticated or logged in for a specific service and the right service has
been provided to the specific user based on their role that is nothing but authorization.

ASP.NET forms authentication occurs after IIS authentication is completed. You can
configure forms authentication by using forms element with in web.config file of your
application. 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
authentication cookie contains a string representation of the encrypted and signed
FormsAuthenticationTicket object.

20. What is Areas in MVC?

From ASP.Net MVC 2.0 Microsoft provided a new feature in MVC applications, Areas.
Areas are just a way to divide or “isolate” the modules of large applications in multiple or
separated MVC. like:
When you add an area to a project, a route for the area is defined in an AreaRegistration
file. The route sends requests to the area based on the request URL. To register routes
for areas, you add code to the Global.asax file that can automatically find the area
routes in the AreaRegistration file.

21. Explain the concept of MVC Scaffolding?

ASP.NET Scaffolding is a code generation framework for ASP.NET Web applications.

Visual Studio 2013 includes pre-installed code generators for MVC and Web API
projects. You add scaffolding to your project when you want to quickly add code that
interacts with data models. Using scaffolding can reduce the amount of time to develop
standard data operations in your project.
Scaffolding consists of page templates, entity page templates, field page templates, and
filter templates. These templates are called Scaffold templates and allow you to quickly
build a functional data-driven Website.
Scaffolding Templates:

Create: It creates a View that helps in creating a new record for the Model. It
automatically generates a label and input field for each property in the Model.
Delete: It creates a list of records from the model collection along with the delete link
with delete record.
Details: It generates a view that displays the label and an input field of the each
property of the Model in the MVC framework.
Edit: It creates a View with a form that helps in editing the current Model. It also
generates a form with label and field for each property of the model.
List: It generally creates a View with the help of a HTML table that lists the Models from
the Model Collection. It also generates a HTML table column for each property of the
Model.

22. What is the difference between ActionResult and ViewResult?

 ActionResult is an abstract class while ViewResult derives from the

ActionResult class.
 ActionResult has several derived classes
like ViewResult, JsonResult, FileStreamResult, and so on.
 ActionResult can be used to exploit polymorphism and dynamism. So if you are
returning different types of views dynamically, ActionResult is the best thing. For
example in the below code snippet, you can see we have a simple action
called DynamicView. Depending on the flag (IsHtmlView) it will either return
a ViewResult or JsonResult.

public ActionResult DynamicView()

{

if (IsHtmlView)

return View(); // returns simple ViewResult

else

return Json(); // returns JsonResult view

23. What is Route Constraints in MVC?

This is very necessary for when we want to add a specific constraint to our URL. So, we
want to set some constraint string after our host name. Fine, let's see how to implement
it.
It's very simple to implement, just open the RouteConfig.cs file and you will find the
routing definition in that. And modify the routing entry as in the following. We will see that
we have added “abc” before.

Controller name, now when we browse we need to specify the string in the URL, as in
the following:
 24. What is Output Caching in MVC?

The main purpose of using Output Caching is to dramatically improve the performance
of an ASP.NET MVC Application. It enables us to cache the content returned by any
controller method so that the same content does not need to be generated each time the
same controller method is invoked. Output Caching has huge advantages, such as it
reduces server round trips, reduces database server round trips, reduces network traffic
etc.

How to Enable Output Caching?

We will create a simple application in Visual Studio first.

Caching In MVC
Caching In MVC

Now we will create a control in our MVC application.

Caching In MVC

So our controller is ready, now we need to create simple view and after that, we will change our
Index action in the controller as below:
 Hide Copy Code

public ActionResult Index()

{
return Content(DateTime.Now.ToString("T"));
}

So we are returning the current time from the controller. Isn’t it? Now refresh your view
frequently, let us say 2 times in 5 minutes, what is the output you are getting?

Caching In MVC
Caching In MVC

So have you noticed that within five minutes, we have hit the controller twice? Now here is the
magic of output cache. Please change your controller code as follows:

Hide Copy Code

[OutputCache(Duration = 300, VaryByParam = "none")]
public ActionResult Index()
{
return Content(DateTime.Now.ToString("T"));
}

Here we are setting the cache duration as 5 minutes (5*60 seconds)

Now if you run and do the same exercise, you can notice that the controller will be hit only once
in a 5 minute duration. That’s cool right?

Even though it is so cool, there are some limitations too. As the memory becomes low, the cache
data will be released so that there won’t be cached data.

Here in our case, we just used a simple view which returns time from the controller. What if the
controller has some database operations, for every user’s hit, we need to go to the database
right? So in simple words, we can say that the caching is helping to reduce the amount of work
done that must be performed by our web server and database.

So contents are cached. Where?

Now, we will see all the locations where we can save the cache data. Usually, the contents are
cached in three locations.

 Web server
 Proxy server
 Web browser

You can always set where you want to save the cached data, whether it is in server, client or both
server and client by using location property. By default, the location will be ‘any’.

Caching In MVC
There are few situations that we should not cache in server. Let me explain, suppose we have a
controller which will return the country name of the user logged in to our application. Now I am
from ‘India’, so when I logged in to the application, it will show the country name as India. That’s
correct. Now have cached these data in the server. So what will happen if a user from Ireland
logged in to the application? Will it be good if we show India as his/her country? It does’t make
any sense, right?

Hide Copy Code

[OutputCache(Duration = 10, VaryByParam = "none")]

public ActionResult Index()
{
User u = new User();
return Content(u.getUserCountry());
}

So in short, we can say that we should not cache any personalized data in the server.

So what is the fix for this? Simple, cache the data in client. To do that, we can change our
controller as follows:

Hide Copy Code

[OutputCache(Duration = 10, VaryByParam = "none",

Location=OutputCacheLocation.Client, NoStore=true)]
public ActionResult Index()
{
User u = new User();
return Content(u.getUserCountry());
}

To use OutputCacheLocation, you must include the namespace using System.Web.UI;

Have you noticed that we have set NoStore=true? This is to intimate the proxy server that
should not save any copies of these data in server.

Use of VaryByParam Property

Now we are going to discuss another scenario which explains the use of VaryByParam property.
Let us say an action called ‘GetEmployee’ will return all the Employees in our company. Now if
we click on any employee links, another view (GetEmployeeDetails) will show with all the
details about that employee (like account details, leave details, personal information). So if we
save the cached view of GetEmployeeDetails, what will happen? For all the employees, it will
show the same GetEmployeeDetails view, right?

So we will change the controller actions as follows:

Hide Copy Code

[OutputCache(Duration = 10, VaryByParam = "none")]

public ActionResult GetEmployee()
{
 Employee e = new Employee();
return Content(e.getEmployees());
}
Hide Copy Code

[OutputCache(Duration = 10, VaryByParam = "empID")]

public ActionResult GetEmployeeDetail(int empID)
{
Employee e = new Employee();
return Content(e.getEmployeeDetails(empID));
}

The above mentioned implementation will make sure the different Employee Details view are
being generated for different users. Sound cool?

Cache Profiles
There is another way of achieving the caching, that is cache profiles, which is nothing but creating
a tag in web .config file and apply that for different controllers. In this way, you can have the same
cache profile for different controls. And also, it is easy to make any changes in the cache profile
since it is just a tag in the web.config file. Any changes in cache profile will get applied easily. I
found this is the most effective way of caching. We can do the cache profile as follows:

Hide Copy Code

<caching>
<outputCacheSettings>
<outputCacheProfiles>
<add name="Admin"

duration="86420" varyByParam="none"/>
</outputCacheProfiles>
</outputCacheSettings>
</caching>

The above cache profile can be used for any admin control action which will be cached for one
day (60*60*24). You can simply use this profile as follows:

Hide Copy Code

[OutputCache(CacheProfile="Admin")]

That is all about the caching. I will come with another post which explains caching in ASP.NET 5,
MVC 6 soon. Thanks for reading. Happy coding!

25. What is the use of Keep and Peek in “TempData”?

Once “TempData” is read in the current request it’s not available in the subsequent
request. If we want “TempData” to be read and also available in the subsequent request
then after reading we need to call “Keep” method as shown in the code below.
@TempData["MyData"];

TempData.Keep("MyData");

The more shortcut way of achieving the same is by using “Peek”. This function helps to
read as well advices MVC to maintain “TempData” for the subsequent request.
string str = TempData.Peek("MyData ").ToString();

26. What is Bundling and Minification in MVC?

Bundling and minification are two new techniques introduced to improve request load
time. It improves load time by reducing the number of requests to the server and
reducing the size of requested assets (such as CSS and JavaScript).
Bundling: It lets us combine multiple JavaScript (.js) files or multiple cascading style
sheet (.css) files so that they can be downloaded as a unit, rather than making individual
HTTP requests.
Minification: It squeezes out whitespace and performs other types of compression to
make the downloaded files as small as possible. At runtime, the process identifies the
user agent, for example IE, Mozilla, etc. and then removes whatever is specific to
Mozilla when the request comes from IE.

27. What is Validation Summary in MVC?

The ValidationSummary helper method generates an unordered list (ul element) of

validation messages that are in the ModelStateDictionary object.
The ValidationSummary can be used to display all the error messages for all the fields. It
can also be used to display custom error messages. The following figure shows how
ValidationSummary displays the error messages.

28. What are the Folders in MVC application solutions?

When you create a project a folder structure gets created by default under the name of
your project which can be seen in solution explorer. Below I will give you a brief
explanation of what these folders are for.
Model: This folder contains classes that is used to provide data. These classes can
contain data that is retrieved from the database or data inserted in the form by the user
to update the database.
Controllers: These are the classes which will perform the action invoked by the user.
These classes contains methods known as "Actions" which responds to the user action
accordingly.
Views: These are simple pages which uses the model class data to populate the HTML
controls and renders it to the client browser.
App_Start: Contains Classes such as FilterConfig, RoutesConfig, WebApiConfig. As of
now we need to understand the RouteConfig class. This class contains the default
format of the URL that should be supplied in the browser to navigate to a specified page.

29. If we have multiple filters, what’s the sequence for execution?

 Authorization filters
 Action filters
 Response filters
 Exception filters

30. What is ViewStart?

Razor View Engine introduced a new layout named _ViewStart which is applied on all
view automatically. Razor View Engine firstly executes the _ViewStart and then start
rendering the other view and merges them.
Example of Viewstart:
@ {

Layout = "~/Views/Shared/_v1.cshtml";

} < !DOCTYPE html >

< html >

< head >

< meta name = "viewport"

content = "width=device-width" / >

< title > ViewStart < /title> < /head> < body >
 < /body> < /html>

31. What is JsonResultType in MVC?

Action methods on controllers return JsonResult (JavaScript Object Notation result) that
can be used in an AJAX application. This class is inherited from the "ActionResult"
abstract class. Here Json is provided one argument which must be serializable. The
JSON result object that serializes the specified object to JSON format.
public JsonResult JsonResultTest()

return Json("Hello My Friend!");

32. What are the Difference between ViewBag&ViewData?

ViewData is a dictionary of objects that is derived from ViewDataDictionary class and

accessible using strings as keys.
ViewBag is a dynamic property that takes advantage of the new dynamic features in C#
4.0.
ViewData requires typecasting for complex data type and check for null values to avoid
error.
ViewBag doesn't require typecasting for complex data type.

Calling of ViewBag is:

ViewBag.Name = "Vikash";

Calling of ViewData is :
ViewData["Name"] = " Vikash ";

33. Explain RenderSection in MVC?

RenderSection() is a method of the WebPageBase class. Scott wrote at one point, The
first parameter to the "RenderSection()" helper method specifies the name of the section
we want to render at that location in the layout template. The second parameter is
optional, and allows us to define whether the section we are rendering is required or not.
If a section is "required", then Razor will throw an error at runtime if that section is not
implemented within a view template that is based on the layout file (that can make it
easier to track down content errors). It returns the HTML content to render.
<div id="body">

@RenderSection("featured", required: false)

<section class="content-wrapper main-content clear-fix">

@RenderBody()

</section>

</div>

34. What is GET and POST Actions Types?

GET
GET is used to request data from a specified resource. With all the GET request we
pass the URL which is compulsory, however it can take the following overloads.
.get(url [, data ] [, success(data, textStatus, jqXHR) ] [, dataType ]
).done/.fail

POST
POST is used to submit data to be processed to a specified resource. With all the POST
requests we pass the URL which is compulsory and the data, however it can take the
following overloads.
.post(url [, data ] [, success(data, textStatus, jqXHR) ] [, dataType ] )

35. What is display mode in MVC?

Display mode displays views depending on the device the user has logged in with. So
we can create different views for different devices and display mode will handle the rest.
For example we can create a view “Home.aspx” which will render for the desktop
computers and Home.Mobile.aspx for mobile devices. Now when an end user sends a
request to the MVC application, display mode checks the “user agent” headers and
renders the appropriate view to the device accordingly.

36. How can we do exception handling in MVC?

In the controller you can override the “OnException” event and set the “Result” to the
view name which you want to invoke when error occurs. In the below code you can see
we have set the “Result” to a view named as “Error”.
We have also set the exception so that it can be displayed inside the view.

public class HomeController : Controller

protected override void OnException(ExceptionContext filterContext)

Exception ex = filterContext.Exception;

filterContext.ExceptionHandled = true;

var model = new HandleErrorInfo(filterContext.Exception,

"Controller","Action");

filterContext.Result = new ViewResult()

{

ViewName = "Error",

ViewData = new ViewDataDictionary(model)

};

To display the above error in view we can use the below code
@Model.Exception;

37. What is the use of remote validation in MVC?

Remote validation is the process where we validate specific data posting data to a
server without posting the entire form data to the server. Let's see an actual scenario, in
one of my projects I had a requirement to validate an email address, whether it already
exists in the database. Remote validation was useful for that; without posting all the data
we can validate only the email address supplied by the user.
Let's create a MVC project and name it accordingly, for me its
“TestingRemoteValidation”. Once the project is created let's create a model named
UserModel that will look like:
public class UserModel

[Required]
 public string UserName

get;

set;

[Remote("CheckExistingEmail", "Home", ErrorMessage = "Email already exists!")]

public string UserEmailAddress

get;

set;

Let's get some understanding of the remote attribute used, so the very first parameter
“CheckExistingEmail” is the the name of the action. The second parameter “Home” is
referred to as controller so to validate the input for the UserEmailAddress the
“CheckExistingEmail” action of the “Home” controller is called and the third parameter is
the error message. Let's implement the “CheckExistingEmail” action result in our home
controller.
public ActionResult CheckExistingEmail(string UserEmailAddress)
{

bool ifEmailExist = false;

try

ifEmailExist = UserEmailAddress.Equals("[email protected]") ? true :

false;

return Json(!ifEmailExist, JsonRequestBehavior.AllowGet);

} catch (Exception ex)

return Json(false, JsonRequestBehavior.AllowGet);

38. Explain Dependency Resolution?

Dependency Resolver again has been introduced in MVC3 and it is greatly simplified the
use of dependency injection in your applications. This turn to be easier and useful for
decoupling the application components and making them easier to test and more
configurable.

39. Explain Bundle.Config in MVC4?

"BundleConfig.cs" in MVC4 is used to register the bundles by the bundling and
minification system. Many bundles are added by default including jQuery libraries like -
jquery.validate, Modernizr, and default CSS references.

40. What is the meaning of Unobtrusive JavaScript?

This is a general term that conveys a general philosophy, similar to the term REST
(Representational State Transfer). Unobtrusive JavaScript doesn't intermix JavaScript
code in your page markup.
Eg : Instead of using events like onclick and onsubmit, the unobtrusive JavaScript
attaches to elements by their ID or class based on the HTML5 data- attributes.