Module 2: Deep Dive into MVC Components


2.1. Models

2.1.1. Understanding Models
Definition and Role of Models
What are models in MVC?
How models represent the data and business logic.
Creating Simple Models
Defining model classes in the Models folder.
Naming conventions for models.

2.1.2. Properties and Data Types
Common Data Types
String, int, decimal, DateTime, bool.
Nullable Types
Using nullable types for optional properties.
Auto-Implemented Properties
Simplifying property definitions.

2.1.3. Data Annotations and Validation
Using Data Annotations
[Required], [StringLength], [Range], [RegularExpression].
[Display] attribute for customizing labels and formats.
Implementing Validation Logic
Server-side validation using data annotations.
Custom validation attributes.
Error Messages and Localization
Customizing validation error messages.
Localizing error messages for different cultures.

2.1.4. Model Binding
How Model Binding Works
Binding form inputs to model properties.
Binding Complex Types
Handling nested objects and collections.
Custom Model Binders
Creating custom binders for special cases.

2.1.5. View Models
Understanding View Models
Separating domain models from presentation models.
Creating View Models
Defining view-specific properties.
Mapping Between Models and View Models
Manual mapping.
Using tools like AutoMapper.

2.1.6. Data Transfer Objects (DTOs)
Purpose of DTOs
Transferring data between layers.
Implementing DTOs
Creating DTO classes.
Mapping data to and from DTOs.

2.1.7. Business Logic in Models
Encapsulating Business Rules
Adding methods and properties that enforce business rules.
Fat Models vs. Anemic Models
Understanding where to place business logic.
Hands-On Exercises

Exercise 1: Create a Product model with properties like Id, Name, Description, Price, CategoryId.
Exercise 2: Apply data annotations to validate the Product model (e.g., [Required], [Range]).
Exercise 3: Implement a custom validation attribute to ensure the Price is a positive value.
Exercise 4: Create a ProductViewModel that includes additional properties like CategoryName for display purposes.


2.2. Views

2.2.1. Introduction to Razor View Engine
What is Razor?
Combining C# code with HTML.
Razor Syntax Basics
Razor code blocks (@{ }), expressions (@), comments (@* *@).
Using C# in Views
Variables, loops (@for, @foreach), conditionals (@if, @else).

2.2.2. Creating and Rendering Views
View Naming Conventions
Matching view names with action methods.
Returning Views from Controllers
Using return View(); and return View("ViewName");.
Passing Data to Views
ViewData (ViewData["Key"]).
ViewBag (ViewBag.PropertyName).
Strongly-typed models (@model directive).

2.2.3. Layouts and Sections
Creating a Layout Page
Defining _Layout.cshtml.
Using Layouts in Views
Setting the layout in views (Layout = "_Layout";).
Defining Sections
Creating sections in views (@section Scripts { }).
Rendering Sections
Using @RenderSection in the layout.

2.2.4. Partial Views
Purpose of Partial Views
Reusing common UI components (e.g., headers, footers).
Creating Partial Views
Naming convention (start with _).
Rendering Partial Views
Using @Html.Partial("_PartialViewName").
Passing Data to Partial Views
Passing models or using ViewData.

2.2.5. Display and Editor Templates
Creating Display Templates
Customizing how data types are displayed.
Creating Editor Templates
Customizing how input fields are rendered.
Using Templates in Views
@Html.DisplayFor and @Html.EditorFor.

2.2.6. Strongly-Typed Views
Advantages of Strongly-Typed Views
IntelliSense support.
Compile-time checking.
Specifying the Model Type
Using @model at the top of the view.
Accessing Model Properties
Using @Model.PropertyName.

2.2.7. HTML Helpers and Tag Helpers
HTML Helpers
Generating form elements (Html.TextBoxFor, Html.LabelFor).
Tag Helpers
Simplifying HTML with Tag Helpers (<input asp-for=""/>, <label asp-for=""/>).
Custom Tag Helpers
Creating reusable components.

2.2.8. Bundling and Minification
Optimizing Static Files
Combining and minifying CSS and JS files.
Using LibMan (Library Manager)
Managing client-side libraries.
Hands-On Exercises
Exercise 1: Create a strongly-typed view to display a list of products.
Exercise 2: Implement a layout page with a header and footer.
Exercise 3: Create partial views for navigation menu and sidebar.
Exercise 4: Use display templates to format product prices.


2.3. Controllers

2.3.1. Understanding Controllers
Role of Controllers
Handling user input and responses.
Creating Controllers
Inheriting from Controller.
Naming Conventions
Controller names end with "Controller".

2.3.2. Action Methods
Defining Action Methods
Public methods that return IActionResult.
Returning Different Results
ViewResult, RedirectToActionResult, JsonResult, ContentResult, FileResult.
Asynchronous Actions
Using async and await.

2.3.3. Parameter Binding
From Query Strings
Automatically binding query parameters.
From Route Data
Binding parameters from URL segments.
From Form Data
Binding form inputs to action parameters.

2.3.4. Redirecting and Passing Data
Redirecting to Other Actions
RedirectToAction, RedirectToRoute.
TempData
Storing data between requests.

2.3.5. Controller Context
Accessing HttpContext
Request and response objects.
Using User.Identity
Accessing user information.

2.3.6. Filters and Action Attributes
Action Filters
Executing code before or after action methods.
Result Filters
Modifying the result before it's sent to the view.
Exception Filters
Handling exceptions globally.
Authorization Filters
Controlling access to actions.

2.3.7. Route Constraints in Controllers
Using Route Attributes
[Route("products/{id:int}")].
HTTP Verb Attributes
[HttpGet], [HttpPost], [HttpPut], [HttpDelete].

Hands-On Exercises
Exercise 1: Create a ProductController with actions for listing, creating, editing, and deleting products.
Exercise 2: Use parameter binding to retrieve product IDs from the URL.
Exercise 3: Implement action filters to log the execution of action methods.


2.4. Hands-On Project for Module 2
Project: Build a basic product management system.
Create models for Product and Category.
Implement views and controllers for CRUD operations.
Use layouts, partial views, and templates for the UI.
Apply validation and data annotations.
Utilize filters for logging and authorization.



INSTRUCTION : EXPLAIN 2.1.3 AND 2.1.4 IN EXTREME DETAIL WITH CODE EXAMPLES. DONT LEAVE OUT ANY TOPIC!