1. What are the main components of the ASP.

NET MVC framework and how do they

interact with each other?

ASP.NET MVC framework consists of three main components: Model, View,

and Controller. These components follow the Model-View-Controller design
pattern to facilitate separation of concerns.

1. Model: Represents application data and business logic. It communicates

with databases, processes data, and enforces validation rules.
2. View: Responsible for displaying the model’s data to users. It defines how
information is presented and receives user input.
3. Controller: Acts as an intermediary between Model and View. It handles
user requests, manipulates the model, and updates the view accordingly.

The interaction begins when a user sends a request to the application. The
routing system maps this request to a specific controller action method. The
controller retrieves relevant data from the model and performs necessary
operations. Then, it selects an appropriate view to display the results and
passes the processed data to that view. Finally, the view renders the data and
presents it to the user.

2. Explain the MVC architecture, specifically how the Model, View, and Controller work
together in the context of ASP.NET MVC?

ASP.NET MVC is a web application framework implementing the Model-View-

Controller (MVC) architectural pattern. In this pattern, Model represents data
and business logic, View displays data to users, and Controller manages user
interactions and updates between Model and View.

In ASP.NET MVC, when a user sends a request, it’s first handled by the
routing system which maps the URL to a specific controller action method.
The controller processes the request, interacts with the Model if necessary,
and selects an appropriate View. Data from the Model can be passed to the
View using ViewData or ViewModel objects.

The View renders HTML based on the provided data and returns it to the user.
Views are typically Razor templates (.cshtml files), allowing for dynamic
content generation. Partial views can also be used for reusable components.

To summarize, in ASP.NET MVC:

1. User requests are routed to controller actions.
2. Controllers handle requests, interact with Models, and select Views.
3. Models represent data and business logic.
4. Views display data to users, using Razor templates for dynamic content.
5. ViewData or ViewModel objects pass data from Models to Views.
6. Partial views enable reusable components.

3. How does the page life cycle differ in ASP.NET Web Forms compared to ASP.NET
MVC?

In ASP.NET Web Forms, the page life cycle involves events like Page_Init,
LoadViewState, LoadPostData, Page_Load, RaisePostBackEvent,
SaveViewState, and Page_Unload. These events enable developers to
handle user interactions and manage control states.

ASP.NET MVC follows a different approach with no view state or server

controls. The life cycle consists of routing, controller instantiation, action
execution, and result rendering. It emphasizes separation of concerns through
Model-View-Controller architecture, enabling better testability and
maintainability.

Key differences include:

1. Absence of view state in MVC, leading to lightweight pages.
2. No server controls in MVC, replaced by HTML helpers for UI generation.
3. Event-driven model in Web Forms versus convention-based actions in
MVC.
4. Better support for unit testing in MVC due to separation of concerns.
5. Web Forms rely on postbacks while MVC uses RESTful URLs for actions.

4. What are the benefits of using ModelState in the context of Model Validation in
ASP.NET MVC?

ModelState benefits in Model Validation context include:

1. Simplified validation: ModelState automatically validates user input against

model data annotations, reducing manual validation code.
2. Error handling: ModelState accumulates errors during validation, allowing
developers to handle and display them efficiently.
3. Binding flexibility: Supports both server-side and client-side validation,
ensuring consistent user experience across platforms.
4. Customization: Developers can extend default validation rules or create
custom ones for specific scenarios.
5. Improved maintainability: Centralized validation logic promotes clean,
modular code that is easier to maintain and debug.
6. Enhanced security: ModelState helps prevent common security
vulnerabilities like XSS and CSRF by validating and sanitizing user inputs.

5. Explain the roles of routing and URL generation in ASP.NET MVC. How does the
framework handle incoming requests?

Routing in ASP.NET MVC is responsible for mapping incoming HTTP

requests to

appropriate controller actions, enabling clean and user-friendly URLs. It uses

a route table containing patterns that define the structure of expected URLs.
URL generation creates URLs based on routing rules, ensuring consistency
across the application.

When an incoming request arrives, the framework matches it against the route
table. If a match is found, the corresponding controller action is invoked with
extracted route values (e.g., parameters). In case of multiple matching routes,
the first one takes precedence. If no match is found, a 404 error is returned.

7. What are the different ways to pass data from the Controller to the View in ASP.NET
MVC?

In ASP.NET MVC, there are four primary methods to pass data from the
Controller to the View:

1. ViewData: A dictionary object that allows you to store key-value pairs. It has
a short lifespan and is only available during the current request.

Example:
ViewData[“Message”] = “Hello World”;

2. ViewBag: A dynamic wrapper around ViewData, providing more flexibility in

accessing stored values without needing explicit casting.

Example:
ViewBag.Message = “Hello World”;

3. TempData: Similar to ViewData but persists across multiple requests,

useful for scenarios like redirecting between actions. TempData internally
uses session state.

Example:
TempData[“Message”] = “Hello World”;
4. Strongly-typed Views: Pass a model object directly to the view, enabling
IntelliSense and compile-time checking of property names and types.

Example:
return View(model);

8. What is Dependency Injection in ASP.NET MVC and how is it utilized? Can you
explain the advantages and disadvantages of using it?

Dependency Injection (DI) in ASP.NET MVC is a design pattern that promotes

loose coupling by injecting dependencies into components, rather than having
them create or access dependencies directly. It’s utilized through Inversion of
Control (IoC) containers, which manage object creation and dependency
resolution.

Advantages:
1. Improved testability: DI allows for easier unit testing by enabling the use of
mock objects.
2. Enhanced maintainability: Loose coupling simplifies code maintenance and
modification.
3. Increased reusability: Components can be reused across different projects
with minimal changes.

Disadvantages:
1. Complexity: Introducing DI may increase initial development complexity.
2. Learning curve: Developers unfamiliar with DI need time to learn and adapt.
3. Performance overhead: Dependency resolution at runtime may cause
minor performance issues.

9. How are attributes used for action filters and what types of action filters does
ASP.NET MVC support?

Attributes are used for action filters in ASP.NET MVC to apply specific
behaviors or logic before or after an action method’s execution. They can be
applied at the controller or action level, allowing customization and modularity.

ASP.NET MVC supports four types of action filters:

1. Authorization Filters: Handle authentication and authorization tasks, e.g.,
AuthorizeAttribute.
2. Action Filters: Perform pre- and post-processing on action methods, e.g.,
OutputCacheAttribute.
3. Result Filters: Modify or replace ActionResult objects returned by action
methods, e.g., HttpStatusCodeResult.
4. Exception Filters: Handle exceptions thrown during action method
execution, e.g., HandleErrorAttribute.

10. What is the Razor View Engine, and how does it differ from alternative view engines
like Web Forms and Spark?

The Razor View Engine is a markup syntax used in ASP.NET MVC for
creating dynamic web pages. It combines C# or VB.NET code with HTML,
enabling seamless server-side logic execution within the view. Razor’s
lightweight and expressive syntax sets it apart from alternatives like Web
Forms and Spark.

Web Forms, an older technology, relies on event-driven programming and

uses a complex page lifecycle. This can lead to less maintainable and harder-
to-test code compared to Razor’s simpler approach. Additionally, Web Forms
use ViewState, which increases page size and load times.

Spark, another alternative, also blends code and markup but has a different
syntax than Razor. While both are extensible, Razor benefits from being
Microsoft-supported and tightly integrated into the ASP.NET MVC framework,
making it more widely adopted and better documented.

11. Explain the concept of ViewData, ViewBag, and TempData. In which scenarios
should each be used?

ViewData, ViewBag, and TempData are mechanisms for passing data

between controllers, actions, and views in ASP.NET MVC.