Configuring DbContext and Migrations in Entity Framework Core

The Foundation of Database Interaction and Evolution

In Entity Framework (EF) Core, the DbContext class is the heart of your data access layer – managing connections, tracking entities, and performing database operations. Migrations, on the other hand, provide a structured way to evolve your database schema as your model changes.

Together, these two components make Code First development powerful, flexible, and production-ready.

🔹 What Is a DbContext?

The DbContext is a lightweight, central class that:

• Manages entity objects during runtime.
• Handles querying and saving data to the database.
• Tracks changes and maintains relationships.
• Bridges your C# model and the database.

You typically create one custom context per domain or database.

🔹 Creating a DbContext

Here’s a simple example of a custom DbContext:

using Microsoft.EntityFrameworkCore;

public class SchoolContext : DbContext
{
    public DbSet<Student> Students { get; set; }
    public DbSet<Course> Courses { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder options)
    {
        options.UseSqlServer("Server=.;Database=SchoolDB;Trusted_Connection=True;");
    }
}

✅ The DbSet<TEntity> properties represent database tables.
✅ The connection string defines which database EF Core connects to.

🔹 Registering DbContext (Dependency Injection)

In ASP.NET Core or other DI-enabled environments, register your context in Program.cs or Startup.cs:

builder.Services.AddDbContext<SchoolContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("SchoolDB")));

And in appsettings.json:

{
  "ConnectionStrings": {
    "SchoolDB": "Server=.;Database=SchoolDB;Trusted_Connection=True;"
  }
}

✅ This approach enables clean dependency injection and testability.
✅ The same context configuration can be reused across your project.

🔹 Overriding OnModelCreating

The OnModelCreating method allows fine-tuned model configuration using the Fluent API.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .Property(s => s.Name)
        .IsRequired()
        .HasMaxLength(100);

    modelBuilder.Entity<Course>()
        .HasMany(c => c.Students)
        .WithMany(s => s.Courses)
        .UsingEntity(j => j.ToTable("StudentCourses"));
}

✅ Define relationships, keys, table names, constraints, and indexes programmatically.
✅ Use this for configurations not expressible through Data Annotations.

🔹 Example Model Setup

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public virtual ICollection<Course> Courses { get; set; } = new List<Course>();
}

public class Course
{
    public int Id { get; set; }
    public string Title { get; set; }
    public virtual ICollection<Student> Students { get; set; } = new List<Student>();
}

🔹 Configuring Database Providers

Entity Framework Core supports multiple providers:

✅ Choose your provider based on your deployment or testing needs.

🔹 Understanding Migrations

Migrations are EF Core’s way of applying incremental schema changes as your model evolves.

When your model changes (e.g., a new property or entity), EF can compare your C# model to the existing database schema and create migration scripts automatically.

🔹 Creating and Applying Migrations

Run these commands in the Package Manager Console or terminal:

1️⃣ Add your first migration:

Add-Migration InitialCreate

Creates a Migrations folder with:

• A migration class (InitialCreate.cs)
• A snapshot of your model

2️⃣ Apply migration to the database:

Update-Database

EF generates and executes the SQL commands to create or update your database schema.

🔹 Viewing Generated SQL

EF Core can show the SQL it generates — useful for debugging or performance analysis:

options.UseSqlServer("connection_string")
       .LogTo(Console.WriteLine, LogLevel.Information);

✅ This prints SQL queries and migration commands to the console during runtime.

🔹 Updating Migrations Over Time

When you modify models (add/remove properties or entities):

Add-Migration AddTeacherTable
Update-Database

To rollback or revert to a previous version:

Update-Database PreviousMigrationName

To remove the last migration (not yet applied):

Remove-Migration

🔹 Customizing Migration Output

Migration files are fully editable C# classes — you can modify them to adjust table names, add indexes, or seed data.

Example snippet from a migration class:

migrationBuilder.CreateTable(
    name: "Students",
    columns: table => new
    {
        Id = table.Column<int>(nullable: false)
            .Annotation("SqlServer:Identity", "1, 1"),
        Name = table.Column<string>(maxLength: 100, nullable: false)
    },
    constraints: table =>
    {
        table.PrimaryKey("PK_Students", x => x.Id);
    });

✅ Migrations are version-controlled, ensuring predictable deployments.

🔹 Seeding Data in Migrations

You can seed initial data using HasData() in OnModelCreating:

modelBuilder.Entity<Course>().HasData(
    new Course { Id = 1, Title = "Mathematics" },
    new Course { Id = 2, Title = "History" }
);

When a migration runs, this data is inserted if not already present.

🔹 Best Practices

• Use dependency injection for DbContext in multi-layered apps.
• Keep one migration per logical change — small and descriptive.
• Never edit generated migrations manually unless you know what you’re doing.
• Always check migration SQL in staging before deploying to production.
• Use InMemoryDatabase for unit tests to avoid external dependencies.

🔹 Common Pitfalls

⚠ Changing entity names after initial migration → may cause EF to drop and recreate tables (potential data loss).
⚠ Multiple contexts pointing to the same database → ensure consistent configuration.
⚠ Forgetting Update-Database → model changes won’t reflect in DB.

🧪 Challenge Task

1. Create a new LibraryContext with Book and Author entities.
2. Configure the relationship: one Author → many Books.
3. Set up OnModelCreating using Fluent API to limit Book.Title to 150 characters.
4. Create and apply migrations:
   • Add-Migration InitialLibrary
   • Update-Database
5. Add seeding data for a default Author and a Book.

Expected Database Result:

Authors
-------
Id | Name
1  | Jane Austen

Books
-------
Id | Title              | AuthorId
1  | Pride and Prejudice | 1

👨‍💻 Want More?

Our C# Deep Dive Course covers:

• Configuring DbContext for multi-environment setups
• Connection resiliency and performance tuning
• Migrations in team environments and CI/CD pipelines
• Schema versioning and rollback strategies
• Advanced seeding and data protection techniques

Mastering DbContext and Migrations means mastering the bridge between your C# models and a living, evolving database — ensuring your applications scale cleanly, safely, and efficiently.