Top 50 ASP.NET MVC Interview Questions and Answers
ASP.NET MVC (Model-View-Controller) is a web application framework developed by Microsoft. It is used for developing web applications by separating the application logic into three components: Model, View, and Controller.
Model: Represents the data or business logic of the application.
View: Represents the UI or presentation layer of the application.
Controller: Handles the user input and updates the model and view accordingly.
The **MVC architecture** divides an application into three main components:
- Model: It represents the data and business logic of the application.
- View: It represents the user interface elements.
- Controller: It acts as an intermediary between the Model and View, handling user inputs and updating the View.
This separation allows for a clean structure and easier maintenance of the application.
Using **MVC** has several advantages:
- Separation of concerns: Helps maintain and organize code.
- Testability: Allows easier unit testing as components are decoupled.
- Scalability: Helps in managing large-scale applications effectively.
- Support for multiple views: Allows different views for different devices.
- Flexibility: Can be used with various view technologies like Razor, Web Forms, etc.
The main differences between **ASP.NET WebForms** and **MVC** are:
- WebForms: Uses a drag-and-drop interface and is event-driven, allowing for rapid development but can lead to complex and difficult-to-maintain code.
- MVC: Provides more control over the application flow and is better suited for complex applications. It requires manual coding for layout and behavior.
- ViewState: WebForms uses ViewState to store page information, while MVC does not.
The **Controller** in MVC is responsible for handling user requests, interacting with the Model, and returning a response. It acts as the intermediary between the View and the Model.
When a user makes a request, the controller receives the input, processes it (e.g., retrieves data, performs logic), and returns a View or performs a redirect.
Example:
public class ProductController : Controller
{
public ActionResult Index()
{
var products = db.Products.ToList();
return View(products);
}
}
A **ViewModel** in MVC is a model specifically designed to be passed to a view. It often contains only the data needed for the view and may not directly correspond to a database entity. It allows you to combine multiple models or add additional properties.
Example:
public class ProductViewModel
{
public string Name { get; set; }
public decimal Price { get; set; }
public string Category { get; set; }
}
**Razor** is a template engine used in ASP.NET MVC for generating HTML markup from C# code. It is a lightweight syntax that allows you to embed server-side code in your web pages easily. Razor files have a `.cshtml` extension.
Example:
@model ProductViewModel@Model.Name
Price: @Model.Price
**Routing** in ASP.NET MVC is the process of mapping URLs to controller actions. It allows the application to respond to different URL patterns with specific logic. This is typically configured in the `RouteConfig.cs` file.
Example: A route could map `/Products/Details/5` to the `Details` action in the `Products` controller with a parameter value of `5`.
In **WebForms**, routing is not a core concept as pages are mapped based on their file name, such as `Page.aspx`. In **MVC**, routing is highly customizable, allowing you to define clean URLs like `/Products/Details/5` without referencing physical files.
The **RouteConfig.cs** file is where you define URL patterns and associate them with controller actions. It configures how the application will respond to different URL patterns.
Example:
public class RouteConfig
{
public static void RegisterRoutes(RouteCollection routes)
{
routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
);
}
}
**Action Methods** in MVC are methods in a controller that respond to user requests. Each action method corresponds to a specific URL and handles the business logic for that URL, returning a result like a View or JSON data.
Example:
public class HomeController : Controller
{
public ActionResult Index()
{
return View();
}
}
**Action Results** are the return types of action methods. An action method can return various types of results like `ViewResult`, `RedirectResult`, `JsonResult`, etc., depending on what needs to be returned to the client.
Example:
public ActionResult GetProduct()
{
var product = db.Products.FirstOrDefault();
return Json(product, JsonRequestBehavior.AllowGet);
}
There are several types of **Action Results** in MVC:
- ViewResult: Returns a view to the user.
- RedirectResult: Redirects the user to another URL.
- JsonResult: Returns JSON data.
- ContentResult: Returns plain text content.
- PartialViewResult: Returns a partial view (a part of a view).
**ViewBag**, **ViewData**, and **TempData** are used to pass data from controller to view:
- ViewData: A dictionary object that stores data for the current request only.
- ViewBag: A dynamic object that wraps around ViewData and allows data to be accessed using properties.
- TempData: Holds data for one request, even if it is redirected.
**Partial Views** are reusable components of a view in MVC. They allow you to render a part of a page (like a header, footer, or sidebar) without reloading the whole page.
Example: You can create a `_Header.cshtml` partial view and render it in the main view:
@Html.Partial("_Header")
**Layouts** in MVC are templates that define the structure of web pages. They help you avoid repeating the same HTML code, such as the header, footer, and navigation menu, across multiple views.
Example: You can define a layout in `_Layout.cshtml` and reference it in your views:
@{
Layout = "~/Views/Shared/_Layout.cshtml";
}
**Scaffolding** is a code generation framework in ASP.NET MVC that automatically creates the basic code for common CRUD (Create, Read, Update, Delete) operations. It speeds up development by generating controllers, views, and models.
Example: You can use the **Add Scaffold** feature in Visual Studio to automatically generate a controller and views for a model.
**Validation** in MVC is done using data annotations in the model class or by using custom validation logic. You can specify required fields, data types, ranges, and custom rules.
Example:
public class Product
{
[Required]
public string Name { get; set; }
[Range(0, 1000)]
public decimal Price { get; set; }
}
**Data Annotations** are attributes used in models to apply validation rules and other metadata to the properties. They are part of the `System.ComponentModel.DataAnnotations` namespace.
Example:
public class User
{
[Required(ErrorMessage = "Username is required")]
public string Username { get; set; }
[EmailAddress]
public string Email { get; set; }
}
Custom validation in MVC can be done by creating a custom validation attribute by inheriting from the `ValidationAttribute` class. This allows you to define your validation logic.
Example:
public class CustomEmailAttribute : ValidationAttribute
{
public override bool IsValid(object value)
{
var email = value as string;
if (email != null && email.Contains("@"))
{
return true;
}
return false;
}
}
**Dependency Injection (DI)** is a design pattern used to manage dependencies between objects. In MVC, DI allows for injecting services like databases, logging, or authentication into controllers or other classes without having to manually create instances.
Example: Register services in `Startup.cs` and inject them into controllers:
public class HomeController : Controller
{
private readonly IProductService _productService;
public HomeController(IProductService productService)
{
_productService = productService;
}
}
In **MVC**, Dependency Injection is implemented by configuring services in the `Startup.cs` file and injecting them into controllers using constructor injection.
Example:
public void ConfigureServices(IServiceCollection services)
{
services.AddScoped();
}
**Filters** are custom logic that can be run before or after an action method executes. They are typically used for cross-cutting concerns like logging, error handling, and authentication.
Types of Filters:
- Authorization Filters: Run before action methods to check if a user is authorized.
- Action Filters: Run before or after action methods are executed.
- Result Filters: Run before or after the action result is executed.
- Exception Filters: Handle exceptions thrown during the action execution.
**Authorization Filters** are used to ensure that a user is authorized to access a specific action or controller. The `Authorize` attribute is commonly used for this purpose.
Example:
[Authorize]
public ActionResult AdminDashboard()
{
return View();
}
**Action Filters** are used to execute code before or after an action method runs. You can use them for logging, performance monitoring, or custom validation.
Example: You can create a custom action filter by implementing the `IActionFilter` interface:
public class LogActionFilter : IActionFilter
{
public void OnActionExecuting(ActionExecutingContext context)
{
// Log action execution
}
public void OnActionExecuted(ActionExecutedContext context)
{
// Log after action execution
}
}
The **Authorize** attribute restricts access to a controller or action method to authorized users only, while the **AllowAnonymous** attribute allows unrestricted access to a controller or action method even if it is applied to a controller that has the **Authorize** attribute.
Example:
[Authorize]
public ActionResult Dashboard()
{
return View();
}
[AllowAnonymous]
public ActionResult Login()
{
return View();
}
**Bundling and Minification** in MVC is a technique used to improve web performance by combining multiple files (CSS, JavaScript) into single bundles and removing unnecessary whitespace and comments from these files.
Example: You can define bundles in `BundleConfig.cs`:
bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
"~/Scripts/jquery-{version}.js"));
bundles.Add(new StyleBundle("~/Content/css").Include(
"~/Content/site.css"));
**TempData** is used to store data that needs to be available for the current and the next request, typically after a redirect. It is different from **ViewBag** and **ViewData**, which persist only for the current request.
Example:
TempData["Message"] = "Data saved successfully!";
Errors in MVC can be handled using the **HandleError** attribute, custom error pages, or global error handling in the `Global.asax` file.
Example: To handle errors globally, you can configure custom error pages in `web.config`:
The **HandleError** attribute in MVC is used to specify that a controller or action should handle any unhandled exceptions and display an error view, like a generic error page or a custom error message.
Example:
[HandleError]
public ActionResult Index()
{
// Code that may throw exceptions
}
**Model Binding** is the process of mapping HTTP request data (like form data) to action method parameters or model properties in MVC.
Example: MVC automatically binds the form fields to the `Product` model:
public ActionResult Create(Product model)
{
if (ModelState.IsValid)
{
// Save product data
}
return View();
}
**Model Validation** ensures that the data passed into a model meets the specified validation rules, such as required fields, data types, and ranges. The **[Required]**, **[Range]**, and **[EmailAddress]** annotations are commonly used for model validation.
Example:
public class Product
{
[Required]
public string Name { get; set; }
[Range(1, 1000)]
public decimal Price { get; set; }
}
**AntiForgeryToken** helps protect MVC applications from Cross-Site Request Forgery (CSRF) attacks. It generates a token in the form and validates it in the controller to ensure the request is legitimate.
Example: Use the `@Html.AntiForgeryToken()` in the form and validate the token in the controller:
[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult Create(Product model)
{
if (ModelState.IsValid)
{
// Save product data
}
return View();
}
Securing an MVC application involves using techniques like input validation, authorization, HTTPS, and preventing CSRF attacks. You should also use authentication and authorization mechanisms, such as ASP.NET Identity.
Example: Configure authentication and authorization in `Startup.cs`:
services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
.AddCookie(options =>
{
options.LoginPath = "/Account/Login";
});
**Server.Transfer** transfers the request to another page on the server without making a round-trip to the client, while **Response.Redirect** sends an HTTP response to the client, which causes the browser to request a new page.
Example:
Server.Transfer("AnotherPage.aspx");
Response.Redirect("NewPage.aspx");
CRUD (Create, Read, Update, Delete) operations can be easily implemented in MVC using Entity Framework. You can use **DbContext** to interact with the database and perform these operations.
Example: Here's how you can implement a basic Create operation:
public class ProductController : Controller
{
private ApplicationDbContext db = new ApplicationDbContext();
[HttpPost]
public ActionResult Create(Product product)
{
if (ModelState.IsValid)
{
db.Products.Add(product);
db.SaveChanges();
return RedirectToAction("Index");
}
return View(product);
}
}
The **Repository Pattern** is a design pattern that abstracts the data access logic from the business logic. It provides a clean interface to interact with the data source.
Example: Implementing a repository for accessing data:
public interface IProductRepository
{
IEnumerable GetAll();
void Add(Product product);
}
public class ProductRepository : IProductRepository
{
private ApplicationDbContext db = new ApplicationDbContext();
public IEnumerable GetAll()
{
return db.Products.ToList();
}
public void Add(Product product)
{
db.Products.Add(product);
db.SaveChanges();
}
}
The **Unit of Work** pattern is used to handle transactions in a database. It ensures that all operations are completed successfully before committing changes, preventing partial updates.
Example: The unit of work typically manages the repository and tracks changes:
public class UnitOfWork : IUnitOfWork
{
private readonly ApplicationDbContext db;
private IProductRepository productRepository;
public UnitOfWork(ApplicationDbContext context)
{
db = context;
}
public IProductRepository ProductRepository
{
get { return productRepository ??= new ProductRepository(db); }
}
public void Commit()
{
db.SaveChanges();
}
}
The **Code First** approach in Entity Framework allows you to define the model classes first and then generate the database schema from them.
Example: Defining a model class and generating a database:
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public decimal Price { get; set; }
}
You can use the **Add-Migration** and **Update-Database** commands to generate and apply the schema changes.
Migrations in Entity Framework Code First are used to manage changes to the database schema over time. When you update your model, you can create a migration to reflect those changes in the database.
Example: To add a migration and update the database, use the following commands:
Add-Migration AddProductTable
Update-Database
**HTML Helpers** in MVC are methods that allow you to generate HTML elements dynamically in views. They simplify rendering HTML code and provide functionality like generating forms, links, and buttons.
Example: Using an HTML helper to create a text box:
@Html.TextBoxFor(m => m.Name)
A **strongly typed HTML Helper** is one that is linked to a model and allows for type-safety and IntelliSense in the view. It automatically binds to the model properties.
Example: Using a strongly typed HTML helper:
@model Product
@Html.TextBoxFor(m => m.Name)
**AJAX (Asynchronous JavaScript and XML)** in MVC allows you to update parts of a page asynchronously, without reloading the whole page. It helps improve user experience by making interactions faster and smoother.
Example: Using jQuery to call a controller action asynchronously:
$.ajax({
url: '@Url.Action("GetProduct", "Product")',
type: 'GET',
success: function (data) {
$('#productDetails').html(data);
}
});
You can call a controller action asynchronously using jQuery's **ajax()** method. This method allows you to send a request to the server and handle the response without refreshing the page.
Example: Calling an action and updating the DOM:
$.ajax({
type: "POST",
url: "@Url.Action('UpdateProduct', 'Product')",
data: { id: 1, name: 'Product A' },
success: function (response) {
$('#productStatus').text(response);
}
});
The **JSONResult** is an ActionResult in MVC that is used to return JSON data from an action method. It can be used to send data to the client-side, which can then be processed by JavaScript or jQuery.
Example: Returning JSON data from a controller action:
public JsonResult GetProductList()
{
var products = db.Products.ToList();
return Json(products, JsonRequestBehavior.AllowGet);
}
The **View()** method returns the same view to the user while rendering the view page on the same request. It renders the same view page and keeps the controller method on the same call.
On the other hand, **RedirectToAction()** redirects the user to another action, potentially in a different controller, causing a new HTTP request.
Example:
public ActionResult Index()
{
return View(); // Keeps the user on the same page
}
public ActionResult RedirectToNewPage()
{
return RedirectToAction("NewPage", "Home"); // Redirects the user to another action
}
To optimize the performance of an MVC application, you can consider the following techniques:
- Enable Bundling and Minification: Reduces the number of HTTP requests and the size of the files.
- Use Output Caching: Cache the result of an action to avoid re-executing it every time.
- Asynchronous Actions: Use asynchronous actions for I/O bound tasks like database or web service calls.
- Reduce View State: Keep the ViewState minimal to improve page load time.
Example: Enabling bundling and minification:
BundleTable.EnableOptimizations = true; // in BundleConfig.cs
In MVC, you can use the **HttpPostedFileBase** class to upload files. The file can be saved to a directory on the server using **File.SaveAs()**.
Example: Uploading a file in an MVC action:
public ActionResult UploadFile(HttpPostedFileBase file)
{
if (file != null && file.ContentLength > 0)
{
var filePath = Path.Combine(Server.MapPath("~/UploadedFiles"), file.FileName);
file.SaveAs(filePath);
}
return RedirectToAction("Index");
}
**Areas** in MVC allow you to divide your application into different modules, each with its own controllers, views, and models. This is useful for large applications with multiple sections or functionalities.
Example: To create an Area, add a new Area in the project:
public class AdminAreaRegistration : AreaRegistration
{
public override string AreaName
{
get { return "Admin"; }
}
public override void RegisterArea(AreaRegistrationContext context)
{
context.MapRoute(
"Admin_default",
"Admin/{controller}/{action}/{id}",
new { action = "Index", id = UrlParameter.Optional }
);
}
}
**Web API** is designed for building HTTP services that can be accessed by a variety of clients, including browsers, mobile devices, and other web applications. It focuses on HTTP-based communication and supports JSON, XML, and other media types.
**MVC** is focused on delivering views (HTML) and is typically used to build web applications that interact with users through a browser.
Example: A Web API controller:
public class ProductApiController : ApiController
{
public IEnumerable Get()
{
return db.Products.ToList();
}
}
In comparison, a typical MVC action would return a view:
public ActionResult Index()
{
return View(db.Products.ToList());
}
){kind=link}
0 Comments