Learning Guide: Building an Employee Management System with ASP.NET Core MVC

Part 1Environment Setup ▼

Part 1: Environment Setup

Before we start coding, we need to install the necessary tools on your computer.

Step 1: Install the .NET SDK ▶

The .NET SDK is the toolkit that allows you to build C# applications.

Download: Go to dotnet.microsoft.com/download

Install: .NET 8.0 SDK (not the Runtime — you need the SDK)

Verify: Open PowerShell and run:

dotnet --version

You should see 8.0.0 or higher.

Step 2: Install SQL Server ▶

For this guide, we'll use SQL Server Developer Edition (free and full-featured).

Download: https://www.microsoft.com/en-us/sql-server/sql-server-downloads

Install: Choose Developer Edition, accept defaults. When prompted for features, ensure:

Database Engine (selected by default)
SQL Server Management Studio (SSMS)

After Installation:

Open SSMS
Connect to your local SQL Server (Server name: typically (localdb)\MSSQLLocalDB or YOUR_COMPUTER_NAME)
Verify you can see "Databases" folder in Object Explorer

If you see this, SQL Server is ready.

Step 3: Install Visual Studio 2022 ▶

Download: https://visualstudio.microsoft.com/

Install: Community Edition (free)

Workload Selection: When prompted, select:

✅ ASP.NET and web development
✅ .NET development (optional, but recommended)

After Installation:

Launch Visual Studio
Skip the sign-in (or sign in if you prefer)
You're ready to create projects

Part 2Understanding MVC Architecture ▼

Part 2: Understanding MVC Architecture

What is MVC? ▶

Before we code, let's understand what "MVC" means and how it shapes our project.

MVC = Model-View-Controller

Think of a restaurant:

Component	Restaurant Analogy	Web App Meaning
Model	The kitchen recipes & ingredient inventory	Data and business logic (Employee, Department classes)
View	The customer's plate (what they see)	HTML pages that display data to users
Controller	The waiter (takes orders, returns results)	C# code that processes user requests and decides what view to show

The Flow:

User fills a form on a web page
        ↓
Form data goes to Controller
        ↓
Controller asks Model to save/fetch data
        ↓
Model talks to the database
        ↓
Controller passes result to View
        ↓
View displays the result to user
                        

Why MVC? ▶

Separation of Concerns: Each part has a single job
Reusability: Models can serve multiple views
Testability: You can test logic without HTML
Maintainability: Easier to find and fix bugs

Part 3Creating Your First Model (Employee) ▼

Part 3: Creating Your First Model (Employee)

What is a Model? ▶

A model is a C# class that represents real-world data. It's the blueprint for what an "Employee" is in your system.

Real-world employee has:

Name
Salary
Department
Date of Birth
Date of Joining

C# model represents this:

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Salary { get; set; }
    // ... other properties
}
                        

Step 1: Create a New ASP.NET Core MVC Project ▶

In Visual Studio:

Click "Create a new project"
Search for "ASP.NET Core Web App (Model-View-Controller)"
Click Next
Project Name: EmployeeManagement
Location: C:\Projects\ (or your preferred folder)
Click Next
Framework: .NET 8.0
Authentication: None (we're learning basics)
Click Create

Visual Studio creates your project structure.

Step 2: Understand the Project Structure ▶

After creation, you'll see:

EmployeeManagement/
├── Controllers/          ← C# code that handles requests
├── Models/              ← Your data classes (currently empty)
├── Views/               ← HTML templates
├── Data/                ← Database context (we'll create this)
├── appsettings.json     ← Configuration file
├── Program.cs           ← Application startup code
└── EmployeeManagement.csproj  ← Project file
                        

Step 3: Create the Employee Model ▶

Right-click on the Models/ folder → Add → Class

Name it: Employee.cs

Copy this code:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace EmployeeManagement.Models
{
    public class Employee
    {
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int Id { get; set; }

        [Required(ErrorMessage = "Name is required")]
        [StringLength(100, MinimumLength = 3, ErrorMessage = "Name must be between 3 and 100 characters")]
        public required string Name { get; set; }

        [Range(0, 9999999, ErrorMessage = "Salary must be between 0 and 99,99, 999")]
        public decimal Salary { get; set; }

        [Required(ErrorMessage = "Date of Birth is required")]
        public DateOnly DateOfBirth { get; set; }

        [Required(ErrorMessage = "Date of Joining is required")]
        public DateOnly DateOfJoining { get; set; }
    }
}
                        

Understanding the Code: OOP Concept #1 - Classes & Properties ▶

public class Employee

class = a blueprint for creating Employee objects
public = anyone can use this class
Similar to saying "Here's what an Employee looks like"

public int Id { get; set; }

public = anyone can read/write this value
int = integer (whole number)
{ get; set; } = allows getting and setting the value
This is called an auto-property in C#

[DatabaseGenerated(...)]

This is a data annotation (metadata that describes the property)
Tells Entity Framework: "Database, auto-generate this ID (1, 2, 3...)"

public DateOnly DateOfBirth

DateOnly = date without time (no hours/minutes)
Perfect for storing birth dates
Different from DateTime which includes time

🎯 Checkpoint: Understand These Concepts

What is the difference between int Id and string Name?
int stores numbers, string stores text
Why do we need [Required] and [StringLength]?
To validate user input before saving to database
What does { get; set; } do?
Allows code to read the value (get) and change it (set)

Part 4Connecting to a Database ▼

Part 4: Connecting to a Database

OOP Concept #2: Inheritance ▶

The DbContext is a special class that connects your C# code to the database. We inherit from Microsoft.EntityFrameworkCore.DbContext.

What is inheritance?

Imagine you're creating a specialized type of something. All cars have wheels, engines, and doors. You inherit these common features rather than redefining them.

public class SportsCar : Car  // SportsCar inherits from Car
{
    public decimal TopSpeed { get; set; }  // Additional property
}
// SportsCar automatically has wheels, engine, doors (inherited)
// Plus the TopSpeed property (new)
                        

Step 1: Create the Database Context ▶

Right-click on the Data/ folder → Add → Class

Name it: ApplicationDbContext.cs

Copy this code:

using Microsoft.EntityFrameworkCore;
using EmployeeManagement.Models;

namespace EmployeeManagement.Data
{
    public class ApplicationDbContext : DbContext
    {
        // Constructor: Receives database configuration options
        public ApplicationDbContext(DbContextOptions options) : base(options)
        {
        }

        // DbSets represent tables in the database
        //  = the class, the table will store Employee objects
        public DbSet Employees { get; set; }
    }
}
                        

Step 2: Configure the Database Connection ▶

Open: Program.cs

Replace the entire content with:

using Microsoft.EntityFrameworkCore;
using EmployeeManagement.Data;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

// Add DbContext - tells the app how to connect to SQL Server
builder.Services.AddDbContext(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseRouting();

app.UseAuthorization();

app.MapStaticAssets();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}")
    .WithStaticAssets();

app.Run();
                        

Step 3: Configure the Connection String ▶

Open: appsettings.json

Replace the entire content with:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=EmployeeManagementDb;Integrated Security=true;TrustServerCertificate=true;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}
                        

Step 4: Create the Database (Migrations) ▶

Now we need to tell Entity Framework to create the actual database table.

Open Package Manager Console:

Tools → NuGet Package Manager → Package Manager Console

Run these commands:

Add-Migration InitialCreate
Update-Database
                        

What happens:

Add-Migration InitialCreate: Creates a migration file (instructions for database changes)
Update-Database: Runs the migration, creates the EmployeeManagementDb database with an Employees table

Verify:

Open SQL Server Management Studio
In Object Explorer, expand Databases
You should see EmployeeManagementDb with an Employees table

Part 5Implementing Index (Display All Employees) ▼

Part 5: Implementing Index (Display All Employees)

Step 1: Create the EmployeesController ▶

Right-click on Controllers/ → Add → Class

Name it: EmployeesController.cs

using Microsoft.AspNetCore.Mvc;
using EmployeeManagement.Data;
using EmployeeManagement.Models;

namespace EmployeeManagement.Controllers
{
    public class EmployeesController : Controller
    {
        // Private field to hold the database context
        private readonly ApplicationDbContext _context;

        // Constructor - receives the context via Dependency Injection
        public EmployeesController(ApplicationDbContext context)
        {
            _context = context;
        }

        // GET: /Employees or /Employees/Index
        // Displays a list of all employees
        public IActionResult Index()
        {
            // Query the database for all employees
            var employees = _context.Employees.ToList();

            // Pass the list to the View
            return View(employees);
        }
    }
}
                        

Step 2: Create the Index View ▶

Create folder: Views/Employees/

Create file: Views/Employees/Index.cshtml

@model List<Employee>

@{
    ViewData["Title"] = "Employees";
}

<div class="container mt-5">
    <h1>Employee List</h1>

    <a href="/Employees/Create" class="btn btn-primary btn-lg">Add an Employee</a>

    <table class="table table-striped">
        <thead>
            <tr>
                <th>ID</th>
                <th>Name</th>
                <th>Salary</th>
                <th>Date of Birth</th>
                <th>Date of Joining</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var employee in Model)
            {
                <tr>
                    <td>@employee.Id</td>
                    <td>@employee.Name</td>
                    <td>@employee.Salary</td>
                    <td>@employee.DateOfBirth</td>
                    <td>@employee.DateOfJoining</td>
                </tr>
            }
        </tbody>
    </table>
</div>
                        

Step 3: Test the Index View ▶

How to Run the Application

In Visual Studio:

Click the green Play button (▶) at the top, or press F5
Wait 5-10 seconds for the application to compile and start
A browser window should open automatically to https://localhost:7xxx

What Should You See

Application starts and you see the Home page
Navigate to https://localhost:7xxx/Employees
You should see:
- A heading "Employee List"
- A button "Add an Employee"
- A table with columns: ID, Name, Salary, Date of Birth, Date of Joining
- The table body is empty (no rows) because you haven't added employees yet

Part 6Implementing Create (Add Employees) ▼

Part 6: Implementing Create (Add Employees)

💡 HTTP GET vs POST

GET Request: User clicks a link or types URL - requests data from server
POST Request: User submits a form - sends data to the server

Step 1: Add Create Methods to Controller ▶

In EmployeesController.cs, add these methods after the Index method:

        // GET: /Employees/Create
        // Displays the form to add a new employee
        public IActionResult Create()
        {
            return View();
        }

        // POST: /Employees/Create
        // Receives form data and saves the employee
        [HttpPost]
        public IActionResult Create(Employee employee)
        {
            // Check if all validation rules passed
            if (!ModelState.IsValid)
            {
                // If validation failed, redisplay the form with errors
                return View(employee);
            }

            // Add the employee to the context
            _context.Employees.Add(employee);

            // Save changes to the database
            _context.SaveChanges();

            // Redirect to Index to show the new employee
            return RedirectToAction("Index");
        }
                        

Step 2: Create the Create View ▶

Create file: Views/Employees/Create.cshtml

@using Microsoft.AspNetCore.Mvc.ModelBinding
@model Employee

@{
    ViewData["Title"] = "Create Employee";
}

<div class="container mt-5">
    <h1>Add New Employee</h1>

    @if (!ViewData.ModelState.IsValid && Model != null)
    {
        <div class="alert alert-danger" role="alert">
            <strong>Please fix the following errors:</strong>
            <ul>
                @foreach(var error in ViewData.ModelState.Values.SelectMany(v => v.Errors))
                {
                    <li>@error.ErrorMessage</li>
                }
            </ul>
        </div>
    }

    <form method="post" action="/Employees/Create">
        <div class="mb-3">
            <label for="Name" class="form-label">Name</label>
            <input type="text" class="form-control" id="Name" name="Name" required />
        </div>

        <div class="mb-3">
            <label for="Salary" class="form-label">Salary</label>
            <input type="number" step="0.01" class="form-control" id="Salary" name="Salary" required />
        </div>

        <div class="mb-3">
            <label for="DateOfBirth" class="form-label">Date Of Birth</label>
            <input type="date" class="form-control" id="DateOfBirth" name="DateOfBirth" required />
        </div>

        <div class="mb-3">
            <label for="DateOfJoining" class="form-label">Date Of Joining</label>
            <input type="date" class="form-control" id="DateOfJoining" name="DateOfJoining" required />
        </div>

        <button type="submit" class="btn btn-primary">Save</button>
        <a href="/Employees/Index" class="btn btn-secondary">Cancel</a>
    </form>
</div>
                        

Step 3: Test Create ▶

What Should You See

Navigate to https://localhost:7xxx/Employees
Click the "Add an Employee" button
You should see a form with fields:
- Name (text input)
- Salary (number input)
- Date Of Birth (date input)
- Date Of Joining (date input)
Fill in example data:
- Name: John Doe
- Salary: 50000
- Date Of Birth: 1990-05-15
- Date Of Joining: 2023-01-10
Click Save
You should be redirected back to Index
The table should now show one row with the employee you just created

Part 7Implementing Edit (Modify Employees) ▼

Part 7: Implementing Edit (Modify Employees)

📝 Edit Overview

Edit is similar to Create, but it:

Loads an existing employee from the database
Displays the form pre-filled with their data
Updates the employee when submitted

Step 1: Add Edit Methods to Controller ▶

        // GET: /Employees/Edit/1
        // Displays the form to edit an employee
        public IActionResult Edit(int id)
        {
            // Find the employee by ID
            var employee = _context.Employees.FirstOrDefault(e => e.Id == id);

            // If not found, return 404
            if (employee == null)
            {
                return NotFound();
            }

            // Display the form with the employee's data
            return View(employee);
        }

        // POST: /Employees/Edit/1
        // Receives form data and updates the employee
        [HttpPost]
        public IActionResult Edit(int id, Employee employee)
        {
            // Update the employee in the context
            _context.Employees.Update(employee);

            // Save changes to the database
            _context.SaveChanges();

            // Redirect to Index
            return RedirectToAction("Index");
        }

Step 2: Create the Edit View ▶

Create file: Views/Employees/Edit.cshtml

@model Employee

<div class="container mt-5">
    <h2>Edit Employee</h2>

    <form method="post" action="/Employees/Edit/@Model.Id">
        <div class="mb-3">
            <label for="id" class="form-label">ID</label>
            <input type="text" class="form-control" id="id" value="@Model.Id" disabled />
            <input type="hidden" name="id" value="@Model.Id" />
        </div>

        <div class="mb-3">
            <label for="name" class="form-label">Name</label>
            <input type="text" class="form-control" id="name" name="Name" value="@Model.Name" required />
        </div>

        <div class="mb-3">
            <label for="salary" class="form-label">Salary</label>
            <input type="number" step="0.01" class="form-control" id="salary" name="Salary" value="@Model.Salary" required />
        </div>

        <div class="mb-3">
            <label for="dob" class="form-label">Date of Birth</label>
            <input type="date" class="form-control" id="dob" name="DateOfBirth" value="@Model.DateOfBirth.ToString("yyyy-MM-dd")" required />
        </div>

        <div class="mb-3">
            <label for="doj" class="form-label">Date of Joining</label>
            <input type="date" class="form-control" id="doj" name="DateOfJoining" value="@Model.DateOfJoining.ToString("yyyy-MM-dd")" required />
        </div>

        <button type="submit" class="btn btn-primary">Update</button>
        <a href="/Employees/Index" class="btn btn-secondary">Cancel</a>
    </form>
</div></div>
                    

Part 8Implementing Delete ▼

Part 8: Implementing Delete

⚠️ Delete Requires Confirmation

Delete requires confirmation to prevent accidental data loss.

Step 1: Add Delete Methods to Controller ▶

        // GET: /Employees/Delete/1
        // Displays a confirmation page
        public IActionResult Delete(int id)
        {
            // Find the employee
            var employee = _context.Employees.FirstOrDefault(e => e.Id == id);

            if (employee == null)
            {
                return NotFound();
            }

            // Display confirmation page
            return View(employee);
        }

        // POST: /Employees/Delete/1
        // Actually deletes the employee
        [HttpPost]
        public IActionResult Delete(int id, Employee employee)
        {
            // Find the employee to delete
            var empToDelete = _context.Employees.FirstOrDefault(e => e.Id == id);

            if (empToDelete != null)
            {
                // Remove from context
                _context.Employees.Remove(empToDelete);

                // Save changes
                _context.SaveChanges();
            }

            // Redirect to Index
            return RedirectToAction("Index");
        }

Step 2: Create the Delete View ▶

Create file: Views/Employees/Delete.cshtml

@model Employee

<div class="container mt-5">
    <h2>Delete Employee</h2>

    <div class="alert alert-danger" role="alert">
        <p><strong>Warning!</strong> This action cannot be undone.</p>
    </div>

    <div class="card mb-4">
        <div class="card-body">
            <p><strong>ID:</strong> @Model.Id</p>
            <p><strong>Name:</strong> @Model.Name</p>
            <p><strong>Salary:</strong> @Model.Salary</p>
            <p><strong>Date of Birth:</strong> @Model.DateOfBirth</p>
            <p><strong>Date of Joining:</strong> @Model.DateOfJoining</p>
        </div>
    </div>

    <p>Are you sure you want to delete this employee?</p>

    <form method="post" action="/Employees/Delete/@Model.Id">
        <input type="hidden" name="id" value="@Model.Id" />
        <button type="submit" class="btn btn-danger">Yes, Delete Employee @Model.Id</button>
        <a href="/Employees/Index" class="btn btn-secondary">Cancel</a>
    </form>
</div></div>
                    

Part 9Adding the Department Model & Relationships ▼

Part 9: Adding the Department Model & Relationships

Understanding Database Relationships ▶

A relationship connects two tables.

Example:

Table: Employees (columns: Id, Name, Salary, DepartmentId)
Table: Departments (columns: Id, Name)

An employee's DepartmentId references a department's Id. This is a Foreign Key.

Benefits:

Avoid duplicate department names
One source of truth for departments
Easy to change department names without modifying all employees

Step 1: Create the Department Model ▶

Right-click Models/ → Add → Class

Name it: Department.cs

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace EmployeeManagement.Models
{
    public class Department
    {
        [Key]
        public short Id { get; set; }

        [Required]
        public required string Name { get; set; }
    }
}
                        

Step 2: Update the Employee Model ▶

Open Models/Employee.cs and update with:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace EmployeeManagement.Models
{
    public class Employee
    {
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int Id { get; set; }

        [Required(ErrorMessage = "Name is required")]
        [StringLength(100, MinimumLength = 3, ErrorMessage = "Name must be between 3 and 100 characters")]
        public required string Name { get; set; }

        [Required(ErrorMessage = "Department is required")]
        public short DepartmentId { get; set; }  // Foreign key to Department table

        [Required]
        public required Department Department { get; set; }  // Navigation property

        [Range(0, 9999999, ErrorMessage = "Salary must be between 0 and 99,99, 999")]
        public decimal Salary { get; set; }

        [Required(ErrorMessage = "Date of Birth is required")]
        public DateOnly DateOfBirth { get; set; }

        [Required(ErrorMessage = "Date of Joining is required")]
        public DateOnly DateOfJoining { get; set; }
    }
}
                        

Step 3: Update the DbContext ▶

Open Data/ApplicationDbContext.cs and update with:

using Microsoft.EntityFrameworkCore;
using EmployeeManagement.Models;

namespace EmployeeManagement.Data
{
    public class ApplicationDbContext : DbContext
    {
        public ApplicationDbContext(DbContextOptions options) : base(options)
        {
        }

        public DbSet Employees { get; set; }
        public DbSet Departments { get; set; }  // Add this line
    }
}
                        

Step 4: Create a Migration & Seed Data ▶

Open Package Manager Console and run:

Add-Migration AddDepartment
Update-Database
                        

Then seed sample departments via SQL Server Management Studio:

INSERT INTO Departments (Id, Name) VALUES
(1, 'Engineering'),
(2, 'Sales'),
(3, 'Marketing'),
(4, 'Human Resources');
                        

Part 10Modifying Create/Edit with Department Dropdown ▼

Part 10: Modifying Create/Edit with Department Dropdown

🎯 UX Improvement

Instead of users remembering department numbers (1, 2, 3), let's show them a dropdown with department names.

Step 1: Update the Create Method ▶

        // GET: /Employees/Create
        public IActionResult Create()
        {
            // Fetch all departments from the database
            var departments = _context.Departments.ToList();

            // Pass departments to the view via ViewBag
            ViewBag.Departments = departments;

            return View();
        }

        [HttpPost]
        public IActionResult Create(Employee employee)
        {
            if (!ModelState.IsValid)
            {
                // If validation fails, repopulate the dropdown
                var departments = _context.Departments.ToList();
                ViewBag.Departments = departments;
                return View(employee);
            }

            _context.Employees.Add(employee);
            _context.SaveChanges();
            return RedirectToAction("Index");
        }

Step 2: Update the Create View ▶

Replace the Department field in Create.cshtml with:

<div class="mb-3">
    <label for="Department" class="form-label">Department</label>
    <select class="form-control" id="departmentId" name="DepartmentId" required>
        <option value="">-- Select Department --</option>
        @foreach (var dept in ViewBag.Departments)
        {
            <option value="@dept.Id">@dept.Name</option>
        }
    </select>
</div></div>
                    

Step 3: Update the Edit Method & View ▶

Update Edit method in controller:

        public IActionResult Edit(int id)
        {
            var employee = _context.Employees.FirstOrDefault(e => e.Id == id);
            if (employee == null)
            {
                return NotFound();
            }

            // Fetch departments for the dropdown
            var departments = _context.Departments.ToList();
            ViewBag.Departments = departments;

            return View(employee);
        }

Update Department field in Edit.cshtml:

<div class="mb-3">
    <label for="department" class="form-label">Department</label>
    <select class="form-control" id="departmentId" name="DepartmentId" required>
        <option value="">-- Select Department --</option>
        @foreach (var dept in ViewBag.Departments)
        {
            @if(Model.DepartmentId == dept.Id)
            {
                <option value="@dept.Id" selected>@dept.Name</option>
            }
            else
            {
                <option value="@dept.Id">@dept.Name</option>
            }
        }
    </select>
</div></div>
                    

Part 11Common Errors & Debugging ▼

Part 11: Common Errors & Debugging

Error: DbContext is not registered in the service container ▶

Cause: Program.cs doesn't have the DbContext registration line.

Solution: Add this line in Program.cs:

builder.Services.AddDbContext(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

Error: Invalid column name 'DepartmentId' ▶

Cause: Model changed but database migration wasn't run.

Solution:

Add-Migration UpdateEmployee
Update-Database

Error: Foreign key constraint violation when saving ▶

Cause: Trying to save an employee with a non-existent DepartmentId.

Solution: Validate that the selected department exists before saving.

Error: Missing Department in the dropdown ▶

Cause: Forgot to populate ViewBag.Departments in the controller.

Solution: Ensure every GET action that displays the form has:

var departments = _context.Departments.ToList();
ViewBag.Departments = departments;

Part 12What You've Learned ▼

Part 12: What You've Learned

🎓 OOP Concepts Covered ▶

1. Classes & Objects

A class is a blueprint, an object is an instance
Properties store data, methods perform actions

2. Inheritance

A class can inherit from another (e.g., EmployeesController : Controller)
Reuses base functionality, adds specialized behavior

3. Dependency Injection

Instead of creating dependencies, receive them
Makes code testable and flexible
Configured in Program.cs, used in constructors

4. Lambda Expressions

Anonymous functions for inline operations
Used in LINQ: e => e.Salary > 50000

5. Relationships & Navigation Properties

Foreign keys connect tables (DepartmentId)
Navigation properties provide access to related data (Department)
.Include() for eager loading

🏗️ ASP.NET Core MVC Patterns ▶

Model-View-Controller Separation

Model: Data classes and business logic
View: HTML templates (Razor syntax)
Controller: Request handlers, business workflow

Request Flow

User submits form (POST) or clicks link (GET)
ASP.NET Core routes to appropriate controller action
Action interacts with database via DbContext
Action returns View with data
View renders HTML and sends to browser

Model Binding

Form data automatically maps to C# objects
Named inputs match property names
Validation runs automatically

🗄️ Entity Framework Core ▶

DbContext

Bridge between C# code and database
Manages object-database mapping
SaveChanges() persists changes

LINQ

Query C# objects as if they're SQL
Type-safe, IntelliSense-enabled

Migrations

Track database schema changes
Add-Migration creates migration file
Update-Database applies migrations

🚀 Next Steps ▶

Now that you have CRUD working, consider:

Easy Enhancements

Sorting: Click column header to sort employees
Searching: Find employees by name
Pagination: Show 10 employees per page

Intermediate

Data Validation: Hire date must be after birth date
Delete Cascading: When a department is deleted, handle its employees
Soft Deletes: Mark employees as "inactive" instead of deleting

Advanced

Authentication: Login system
Authorization: Admin-only delete operation
API Layer: Return JSON instead of HTML
Unit Testing: Test controller logic without database

💡 Learning Tips ▶

Don't copy-paste: Type every line. Your fingers learn the syntax.
Modify and experiment: After getting it working, change things to see what breaks.
Read error messages: They're usually helpful. Use them to debug.
Use the debugger: Set breakpoints, step through code, inspect variables.
Explain to yourself: If you can explain your code to someone else, you understand it.
Build projects: The best way to learn is by building. Create projects, fail, debug, learn.

📚 Resources ▶

Official Docs: https://learn.microsoft.com/en-us/aspnet/core/
Entity Framework: https://learn.microsoft.com/en-us/ef/core/
C# Language: https://learn.microsoft.com/en-us/dotnet/csharp/

🎉 Congratulations!

You've completed the ASP.NET Core MVC Learning Guide. You now understand:

MVC architecture and how it separates concerns
Creating models, controllers, and views
Database connectivity with Entity Framework
CRUD operations (Create, Read, Update, Delete)
Database relationships and foreign keys
OOP concepts including inheritance, dependency injection, and relationships

Keep building, keep learning, and happy coding! 🚀

🎓 Learning Guide: Building an Employee Management System

📚 Table of Contents

Part 1: Environment Setup

Part 2: Understanding MVC Architecture

MVC = Model-View-Controller

The Flow:

Part 3: Creating Your First Model (Employee)

Part 4: Connecting to a Database

Part 5: Implementing Index (Display All Employees)

How to Run the Application

What Should You See

Part 6: Implementing Create (Add Employees)

What Should You See

Part 7: Implementing Edit (Modify Employees)

Part 8: Implementing Delete

Part 9: Adding the Department Model & Relationships

Part 10: Modifying Create/Edit with Department Dropdown

Part 11: Common Errors & Debugging

Part 12: What You've Learned

1. Classes & Objects

2. Inheritance

3. Dependency Injection

4. Lambda Expressions

5. Relationships & Navigation Properties

Model-View-Controller Separation

Request Flow

Model Binding

DbContext

LINQ

Migrations

Easy Enhancements

Intermediate

Advanced