40 ASP.NET MVC Interview Questions (ANSWERED) .NET Devs Have To Know

ASP.NET Web API is a framework that simplifies building HTTP services for broader range of clients (including browsers as well as mobile devices) on top of .NET Framework.

Using ASP.NET Web API, we can create non-SOAP based services like plain XML or JSON strings, etc. with many other advantages including:

• Create resource-oriented services using the full features of HTTP
• Exposing services to a variety of clients easily like browsers or mobile devices, etc.

Layout pages are similar to master pages in traditional web forms. This is used to set the common look across multiple pages. In each child page we can find

@{
Layout = “~/Views/Shared/TestLayout1.cshtml”;
}

This indicates child page uses TestLayout page as it’s master page.

• Model — It’s a business entity and it is used to represent the application data.
• Controller — Request sent by the user always scatters through controller and it’s responsibility is to redirect to the specific view using View() method.
• View — It’s the presentation layer of MVC.

Section are the part of HTML which is to be rendered in layout page. In Layout page we will use the below syntax for rendering the HTML –

@RenderSection(“TestSection”)

And in child pages we are defining these sections as shown below –

@section TestSection{
     <h1>Test Content</h1>
}

More new features introduced in ASP.NET Web API framework v2.0 are as follows:

• Attribute Routing
• External Authentication
• CORS (Cross-Origin Resource Sharing)
• OWIN (Open Web Interface for .NET) Self Hosting
• IHttpActionResult
• Web API OData

Actions are the methods in Controller class which is responsible for returning the view or json data. Action will mainly have return type — ActionResult and it will be invoked from method  InvokeAction() called by controller.

Scaffold templates are used to generate code for basic CRUD operations within your ASP.NET MVC applications against your database with the help Entity Framework.

Microsoft provides a helpful scaffolding engine, powered by T4 templates, that automates creating basic CRUD controllers and views for models in ASP.NET MVC applications that use the Entity Framework. (There are also WebAPI and MVC without Entity Framework scaffolders currently available.)

In MVC all public methods have been treated as Actions. So if you are creating a method and if you do not want to use it as an action method then the method has to be decorated with NonAction attribute as shown below:

[NonAction]
public void TestMethod()
{
   // Method logic
}

Using ASP.NET Web API has a number of advantages, but core of the advantages are:

• It works the HTTP way using standard HTTP verbs like GET, POST, PUT, DELETE, etc. for all CRUD operations
• Complete support for routing
• Response generated in JSON or XML format using MediaTypeFormatter
• It has the ability to be hosted in IIS as well as self-host outside of IIS
• Supports Model binding and Validation
• Support for OData

• Provides a clean separation of concerns among UI (Presentation layer), model (Transfer objects/Domain Objects/Entities) and Business Logic (Controller).
• Easy to UNIT Test
• Improved reusability of model and views. We can have multiple views which can point to the same model and vice versa.
• Improved structuring of the code

ASP.NET Core is a brand new cross-platform web framework built with .NET Core framework. It is not an update to existing ASP.NET framework. It is a complete rewrite of the ASP.NET framework. It works with both .NET Core and .NET Framework.

Main characterestics of ASP.NET Core:

• DI Container which is quite simple and built-in. You can extend it with other popular DI containers
• Built-in and extensible structured logging. You can redirect output to as many sources as you want (file, Azure, AWS, console)
• Extensible strongly typed configuration, which can also be used to reload at run-time
• Kestrel – new, cross-platform and super fast web server which can stand alone without IIS, Nginx or Apache
• New, fully async pipeline. It is easily configured via middleware
• ASP.NET All meta package which improves development speed, and enables you to reference all Microsoft packages for ASP.NET Core and it will deploy only those that are being used by your code
• There is no web.config. We now use appsettings.json file in combination with other sources of configuration (command line args, environment variables, etc.)
• There is no Global._asax – We have _Startup.cs which is used to set up Middleware and services for DI Container.

Razor is the first major update to render HTML in MVC 3. Razor was designed specifically for view engine syntax. Main focus of this would be to simplify and code-focused templating for HTML generation. Below is the sample of using Razor:

@model MvcMusicStore.Models.Customer
@{ViewBag.Title = “Get Customers”;}
<div class=”cust”> <h3><em>@Model.CustomerName</em> </h3>

ViewModel is a plain class with properties, which is used to bind it to strongly typed view. ViewModel can have the validation rules defined for its properties using data annotations.

Routing is a pattern matching mechanism of incoming requests to the URL patterns which are registered in route table. Class — “UrlRoutingModule” is used for the same process.

Yes, we can share a view across multiple controllers. We can put the view in the Shared folder. When we create a new MVC Project we can see the Layout page will be added in the shared folder, which is because it is used by multiple child pages.

• RenderBody is like ContentPlaceHolder in web forms. This will exist in layout page and it will render the child pages/views. Layout page will have only one RenderBody() method.

• RenderPage also exists in Layout page and multiple RenderPage() can be there in Layout page.

Below are the processed followed in the sequence:

• App initialization
• Routing
• Instantiate and execute controller
• Locate and invoke controller action
• Instantiate and render view

• Windows Communication Foundation is designed to exchange standard SOAP-based messages using variety of transport protocols like HTTP, TCP, NamedPipes or MSMQ, etc.
• On the other hand, ASP.NET API is a framework for building non-SOAP based services over HTTP only.

Usually, WebAPI used for data services where MVC can generate more types of outputs (like template HTML views).

• WebAPI simplifies the way we can create REST data services. It's clean and easy for this purpose.
• MVC can generate any output WebAPI can output. Generating outputs from templates can be easily achieved in MVC. I can't find a reason to do so in WebAPI.

• The purpose of Web API framework is to generate HTTP services that reach more clients by generating data in raw format, for example, plain XML or JSON string. So, ASP.NET Web API creates simple HTTP services that renders raw data.
• On the other hand, ASP.NET MVC framework is used to develop web applications that generate Views (HTML) as well as data. ASP.NET MVC facilitates in rendering HTML easy.

HTML Helpers are like controls in traditional web forms. But HTML helpers are more lightweight compared to web controls as it does not hold viewstate and events.

HTML Helpers returns the HTML string which can be directly rendered to HTML page. Custom HTML Helpers also can be created by overriding HtmlHelper class.

This is introduced in MVC5. In this type of routing, attributes are being used to define the routes. This type of routing gives more control over classic URI Routing. Attribute Routing can be defined at controller level or at Action level like:

[Route('{action = TestCategoryList}')]  // Controller Level
[Route('customers/{TestCategoryId:int:min(10)}')]  // Action Level

PartialView is similar to UserControls in traditional web forms. Partial views are used for re-usability purpose . Since it's been shared with multiple views these are kept in shared folder. Partial Views can be rendered in following ways:

• Html.Partial()
• Html.RenderPartial()

ViewBag is a wrapper around ViewData, which allows to create dynamic properties.

Advantage of viewbag over viewdata will be:

• In ViewBag no need to typecast the objects as in ViewData.
• ViewBag will take advantage of dynamic keyword which is introduced in version 4.0. But before using ViewBag we have to keep in mind that ViewBag is slower than ViewData.

• ActionResult is an abstract class.
• ViewResult derives from ActionResult. Other derived classes include JsonResult and PartialViewResult.

The only difference is that with the ActionResult one, your controller isn't promising to return a view - you could change the method body to conditionally return a RedirectResult or something else without changing the method definition.

And some ActionResult subtypes are:

• ViewResult - Renders a specifed view to the response stream
• PartialViewResult - Renders a specifed partial view to the response stream
• EmptyResult - An empty response is returned
• RedirectResult - Performs an HTTP redirection to a specifed URL
• 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