Curriculum
Code First Approach and Migrations in Entity Framework Core are among the most powerful features of EF Core. Instead of creating database tables manually, developers create C# classes, and Entity Framework Core automatically generates and manages the database structure. This approach improves productivity, supports version control, and simplifies database management throughout the software development lifecycle.
Understanding Code First Approach and Migrations in Entity Framework Core is essential because most modern ASP.NET Core applications use this methodology to build scalable, maintainable, and enterprise-grade database applications.
The Code First Approach means:
Write C# Classes
↓
Generate Database
↓
Manage Schema Through CodeDevelopers design application models first, and EF Core creates the database structure automatically.
Without Code First:
Create Tables Manually
Manage Database Changes Manually
Write SQL Scripts FrequentlyWith Code First:
Automatic Table Creation
Automatic Schema Updates
Version Controlled DatabaseThis significantly improves development efficiency.
Traditional Process:
Database First
↓
Tables Created
↓
Application BuiltDatabase design starts before application development.
Code First Process:
Models Created
↓
Database Generated
↓
Application DevelopedThe application drives database creation.
Example:
public class Student
{
public int Id
{
get;
set;
}
public string Name
{
get;
set;
}
public string Course
{
get;
set;
}
}This model becomes a database table.
Entity:
StudentDatabase:
Students TableProperties become columns automatically.
Example:
Students
----------------
Id
Name
CourseEF Core creates the table based on the entity.
Migrations are a feature that manages database schema changes over time.
Purpose:
Track Database Changes
Apply Updates
Maintain VersionsMigrations keep databases synchronized with application models.
Applications evolve.
Examples:
Add Columns
Remove Columns
Rename Columns
Create TablesMigrations manage these changes safely.
Modify Model
↓
Create Migration
↓
Apply Migration
↓
Update DatabaseThis is the standard EF Core workflow.
Example:
public class
ApplicationDbContext :
DbContext
{
public DbSet<Student>
Students
{
get;
set;
}
}DbContext is required before migrations can be used.
Common Package:
Microsoft.EntityFrameworkCore.ToolsThese tools enable migration commands.
Program.cs:
builder.Services
.AddDbContext<
ApplicationDbContext>(
options =>
options.UseSqlServer(
connectionString));EF Core now knows how to connect to the database.
Package Manager Console:
Add-Migration
InitialCreateResult:
Migration File CreatedThis migration represents the initial database structure.
Examples:
InitialCreate
AddStudentTable
AddCourseColumn
CreateAttendanceTableUse descriptive migration names.
EF Core generates:
Migration Class
Snapshot FileThese files track schema history.
Generated Code:
migrationBuilder
.CreateTable(
name: "Students");EF Core automatically creates SQL instructions.
EF Core maintains:
Model SnapshotPurpose:
Track Current Schema
Compare Future ChangesThis helps EF Core generate accurate migrations.
Command:
Update-DatabaseResult:
Database Created
Tables CreatedThe migration is applied to the database.
Example:
Students Table CreatedThe schema now matches the entity model.
Example:
public string Email
{
get;
set;
}The model changes.
Command:
Add-Migration
AddStudentEmailEF Core detects the new property.
Generated Action:
Add Column EmailThe migration updates the schema.
Command:
Update-DatabaseResult:
Email Column AddedThe database stays synchronized.
EF Core creates:
__EFMigrationsHistoryPurpose:
Track Applied MigrationsThis table prevents duplicate migration execution.
Command:
Remove-MigrationPurpose:
Delete Last MigrationUseful when a migration was created incorrectly.
Example:
Update-Database
InitialCreateThe database returns to a previous migration state.
InitialCreate
↓
AddStudentEmail
↓
AddCourseTable
↓
AddAttendanceTableEach migration represents a database change.
Database structures are generated automatically.
Schema originates from C# classes.
Database changes are tracked in source control.
Database updates become predictable.
All developers share migration history.
These benefits make Code First highly popular.
Student Management System:
Entities:
Student
Teacher
Course
Attendance
ResultMigrations generate all required tables automatically.
Entities:
Doctor
Patient
Appointment
PrescriptionDatabase structure evolves through migrations.
Entities:
Product
Category
Customer
Order
PaymentCode First creates and updates the schema.
Create Migration:
Add-Migration
MigrationNameApply Migration:
Update-DatabaseRemove Migration:
Remove-MigrationGenerate SQL Script:
Script-MigrationThese commands are frequently used.
Reduces manual work.
Tracks changes over time.
Supports continuous development.
Database changes become part of the project.
Works well for large applications.
These advantages improve software development workflows.
May create schema issues.
Database will not be updated.
Makes maintenance difficult.
Can complicate troubleshooting.
May cause deployment problems.
Code First creates database structures from C# classes.
Migrations manage database schema changes over time.
Add-Migration.
Update-Database.
A table that tracks applied migrations.
They simplify database creation, updates, and schema version management.
The Code First Approach creates database tables from C# entity classes.
Migrations are used to track and apply database schema changes.
Add-Migration creates a new migration file.
Update-Database applies migrations to the database.
Code First improves productivity and keeps the database synchronized with application code.
They provide automated database creation, schema management, and version control capabilities.