Post navigation

MVC interview questions with answers

What is MVC (Model View Controller)?

MVC is an architectural pattern which separates the representation and user interaction. It’s divided into three broader sections, Model, View, and Controller. Below is how each one of them handles the task.

The View is responsible for the look and feel.

Model represents the real world object and provides data to the View.

The Controller is responsible for taking the end user request and loading the appropriate Model and View.

Figure: MVC (Model view controller)

Can you explain the complete flow of MVC?

Below are the steps to control flows in MVC (Model, View, and controller) architecture:

All end user requests are first sent to the controller.

The controller depending on the request decides which model to load. The controller loads the model and attaches the model with the appropriate view.

The final view is then attached with the model data and sent as a response to the end user on the browser.

Is MVC suitable for both Windows and Web applications?

The MVC architecture is suited for a web application than Windows. For Window applications, MVP, i.e., “Model View Presenter” is more applicable. If you are using WPF and Silverlight, MVVM is more suitable due to bindings.

What are the benefits of using MVC?

There are two big benefits of MVC:

Separation of concerns is achieved as we are moving the code-behind to a separate class file. By moving the binding code to a separate class file we can reuse the code to a great extent.

Automated UI testing is possible because now the behind code (UI interaction code) has moved to a simple .NET class. This gives us opportunity to write unit tests and automate manual testing.

Is MVC different from a three layered architecture?

MVC is an evolution of a three layered traditional architecture. Many components of the three layered architecture are part of MVC. So below is how the mapping goes:

Functionality

Three layered / tiered architecture

Model view controller architecture

Look and Feel

User interface

View

UI logic

User interface

Controller

Business logic /validations

Middle layer

Model

Request is first sent to

User interface

Controller

Accessing data

Data access layer

Data Access Layer

Figure: Three layered architecture

What is the latest version of MVC?

When this note was written, four versions were released of MVC: MVC 1 , MVC 2, MVC 3, and MVC 4. So the latest is MVC 4.

What is the difference between each version of MVC?

Below is a detailed table of differences. But during an interview it’s difficult to talk about all of them due to time limitation. So I have highlighted the important differences that you can run through before the interviewer.

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

What is routing in MVC?

Routing helps you to define a URL structure and map the URL with the controller.

For instance let’s say we want that when a user types “http://localhost/View/ViewCustomer/”, it goes to the “Customer” Controller and invokes the DisplayCustomer action. This is defined by adding an entry in to the routescollection using the maproute function. Below is the underlined code which shows how the URL structure and mapping with controller and action is defined.

How can we restrict MVC actions to be invoked only by GET or POST?

We can decorate the MVC action with the HttpGet or HttpPost attribute to restrict the type of HTTP calls. For instance you can see in the below code snippet the DisplayCustomer action can only be invoked by HttpGet. If we try to make HTTP POST on DisplayCustomer, it will throw an error.

How can we maintain sessions in MVC?

Sessions can be maintained in MVC by three ways: tempdata, viewdata, and viewbag.

What is the difference between tempdata, viewdata, and viewbag?

Figure: Difference between tempdata, viewdata, and viewbag

Temp data – Helps to maintain data when you move from one controller to another controller or from one action to another action. In other words when you redirect, tempdata helps to maintain data between those redirects. It internally uses session variables.

View data – Helps to maintain data when you move from controller to view.

View Bag – It’s a dynamic wrapper around view data. When you use Viewbag type, casting is not required. It uses the dynamic keyword internally.

Figure: dynamic keyword

Session variables – By using session variables we can maintain data from any entity to any entity.

Hidden fields and HTML controls – Helps to maintain data from UI to controller only. So you can send data from HTML controls or hidden fields to the controller using POST or GET HTTP methods.

Below is a summary table which shows the different mechanisms for persistence.

Maintains data between

ViewData/ViewBag

TempData

Hidden fields

Session

Controller to Controller

No

Yes

No

Yes

Controller to View

Yes

No

No

Yes

View to Controller

No

No

Yes

Yes

What are partial views 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.

Figure: Partial views in MVC

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.

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.RenderPartialmethod as shown in the below code snippet:

How can we do validations in MVC?

One of the easiest ways of doing validation in MVC is by using data annotations. Data annotations are nothing but attributes which can be applied on model properties. For example, in the below code snippet we have a simpleCustomer class with a property customercode.

This CustomerCode property is tagged with a Required data annotation attribute. In other words if this model is not provided customer code, it will not accept it.

Then in the controller or on the action, you can use the Authorize attribute which specifies which users have access to these controllers and actions. Below is the code snippet for that. Now only the users specified in the controller and action can access it.

All the other actions need to be attributed with the Authorize attribute so that any unauthorized user making a call to these controllers will be redirected to the controller (in this case the controller is “Login”) which will do the authentication.

How to implement AJAX in MVC?

You can implement AJAX in two ways in MVC:

AJAX libraries

jQuery

Below is a simple sample of how to implement AJAX by using the “AJAX” helper library. In the below code you can see we have a simple form which is created by using the Ajax.BeginForm syntax. This form calls a controller action calledgetCustomer. So now the submit action click will be an asynchronous AJAX call.

In case you want to make AJAX calls on hyperlink clicks, you can use the Ajax.ActionLink function as shown in the below code.

Figure: Implement AJAX in MVC

So if you want to create an AJAX asynchronous hyperlink by name GetDate which calls the GetDate function in the controller, below is the code for that. Once the controller responds, this data is displayed in the HTML DIV tag namedDateDiv.

The second way of making an AJAX call in MVC is by using jQuery. In the below code you can see we are making an AJAX POST call to a URL /MyAjax/getCustomer. This is done by using $.post. All this logic is put into a function calledGetData and you can make a call to the GetData function on a button or a hyperlink click event as you want.

What kind of events can be tracked in AJAX?

What is the difference between ActionResult and ViewResult?

ActionResult is an abstract class while ViewResult derives from the ActionResult class. ActionResulthas 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 aViewResult or JsonResult.

RedirectToRouteResult – Performs an HTTP redirection to a URL that is determined by the routing engine, based on given route data

JsonResult – Serializes a given ViewData object to JSON format

JavaScriptResult – Returns a piece of JavaScript code that can be executed on the client

ContentResult – Writes content to the response stream without requiring a view

FileContentResult – Returns a file to the client

FileStreamResult – Returns a file to the client, which is provided by a Stream

FilePathResult – Returns a file to the client

What are ActionFilters in MVC?

ActionFilters help you to perform logic while an MVC action is executing or after an MVC action has executed.

Figure: ActionFilters in MVC

Action filters are useful in the following scenarios:

Implement post-processing logic before the action happens.

Cancel a current execution.

Inspect the returned value.

Provide extra data to the action.

You can create action filters by two ways:

Inline action filter.

Creating an ActionFilter attribute.

To create an inline action attribute we need to implement the IActionFilter interface. The IActionFilterinterface has two methods: OnActionExecuted and OnActionExecuting. We can implement pre-processing logic or cancellation logic in these methods.

The problem with the inline action attribute is that it cannot be reused across controllers. So we can convert the inline action filter to an action filter attribute. To create an action filter attribute we need to inherit fromActionFilterAttribute and implement the IActionFilter interface as shown in the below code.

Later we can decorate the controllers on which we want the action attribute to execute. You can see in the below code I have decorated the Default1Controller with the MyActionAttribute class which was created in the previous code.

Can we create our custom view engine using MVC?

Yes, we can create our own custom view engine in MVC. To create our own custom view engine we need to follow three steps:

Let’ say we want to create a custom view engine where in the user can type a command like “<DateTime>” and it should display the current date and time.

Step 1: We need to create a class which implements the IView interface. In this class we should write the logic of how the view will be rendered in the render function. Below is a simple code snippet for that.

Step 2: We need to create a class which inherits from VirtualPathProviderViewEngine and in this class we need to provide the folder path and the extension of the view name. For instance, for Razor the extension is “cshtml”; for aspx, the view extension is “.aspx”, so in the same way for our custom view, we need to provide an extension. Below is how the code looks like. You can see the ViewLocationFormats is set to the Views folder and the extension is “.myview”.

Step 3: We need to register the view in the custom view collection. The best place to register the custom view engine in the ViewEngines collection is the global.asax file. Below is the code snippet for that.

Below is the JSON output of the above code if you invoke the action via the browser.

What is WebAPI?

HTTP is the most used protocol. For the past many years, browser was the most preferred client by which we consumed data exposed over HTTP. But as years passed by, client variety started spreading out. We had demand to consume data on HTTP from clients like mobile, JavaScript, Windows applications, etc.

For satisfying the broad range of clients REST was the proposed approach. You can read more about REST from the WCF chapter.

WebAPI is the technology by which you can expose data over HTTP following REST principles.

But WCF SOAP also does the same thing, so how does WebAPI differ?

SOAP

WEB API

Size

Heavy weight because of complicated WSDL structure.

Light weight, only the necessary information is transferred.

Protocol

Independent of protocols.

Only for HTTP protocol

Formats

To parse SOAP message, the client needs to understand WSDL format. Writing custom code for parsing WSDL is a heavy duty task. If your client is smart enough to create proxy objects like how we have in .NET (add reference) then SOAP is easier to consume and call.

Output of WebAPI are simple string messages, JSON, simple XML format, etc. So writing parsing logic for that is very easy.

With WCF you can implement REST, so why WebAPI?

WCF was brought into implement SOA, the intention was never to implement REST. WebAPI is built from scratch and the only goal is to create HTTP services using REST. Due to the one point focus for creating REST service, WebAPI is more preferred.

How to implement WebAPI in MVC

Below are the steps to implement WebAPI:

Step 1: Create the project using the WebAPI template.

Figure: Implement WebAPI in MVC

Step 2: Once you have created the project you will notice that the controller now inherits from ApiController and you can now implement POST, GET, PUT, and DELETE methods of the HTTP protocol.

What is bundling and minification in MVC?

Bundling and minification helps us improve request load times of a page thus increasing performance.

How does bundling increase performance?

Web projects always need CSS and script files. Bundling helps us combine multiple JavaScript and CSS files in to a single entity thus minimizing multiple requests in to a single request.

For example consider the below web request to a page . This page consumes two JavaScript files Javascript1.js andJavascript2.js. So when this is page is requested it makes three request calls:

One for the Index page.

Two requests for the other two JavaScript files: Javascript1.js and Javascript2.js.

The below scenario can become worse if we have a lot of JavaScript files resulting in multiple requests, thus decreasing performance. If we can somehow combine all the JS files into a single bundle and request them as a single unit that would result in increased performance (see the next figure which has a single request).

So how do we implement bundling in MVC?

Open BundleConfig.cs from the App_Start folder.

In BundleConfig.cs, add the JS files you want bundle into a single entity in to the bundles collection. In the below code we are combining all the javascript JS files which exist in the Scripts folder as a single unit in to the bundle collection.

How do we implement minification?

When you implement bundling, minification is implemented by itself. In other words the steps to implement bundling and minification are the same.

Explain Areas in MVC?

Areas help you to group functionalities in to independent modules thus making your project more organized. For example in the below MVC project we have four controller classes and as time passes by if more controller classes are added it will be difficult to manage. In bigger projects you will end up with 100’s of controller classes making life hell for maintenance.

If we can group controller classes in to logical section like “Invoicing” and “Accounting” that would make life easier and that’s what “Area” are meant to.

You can add an area by right clicking on the MVC solution and clicking on “Area” menu as shown in the below figure.

In the below image we have two “Areas” created “Account” and “Invoicing” and in that I have put the respective controllers. You can see how the project is looking more organized as compared to the previous state.