Fix: Entity Framework Migration Not Working Error - Complete EF Core Guide

The ‘Entity Framework Migration Not Working’ error is a common issue in .NET applications that use Entity Framework Core for database operations. This error occurs when EF migrations fail to execute properly, causing database schema synchronization problems. Understanding and resolving this error is crucial for maintaining consistent database schemas in your .NET applications.

This comprehensive guide explains what causes Entity Framework migration errors, why they happen, and provides multiple solutions to fix and prevent them in your .NET projects with clean code examples and directory structure.

---

What is the Entity Framework Migration Error?

Entity Framework migration errors occur when:

• Migration commands fail to execute in Package Manager Console or CLI
• Database schema doesn’t match the model definitions
• Migration files are corrupted or missing
• Multiple developers have conflicting migrations
• Database connection issues prevent migration execution
• Migration dependencies are not properly configured
• Model changes are incompatible with existing migrations

Common Error Messages:

• System.InvalidOperationException: The model backing the 'DbContext' context has changed since the database was created
• Microsoft.EntityFrameworkCore.Migrations: Migration failed to execute
• System.Data.SqlClient.SqlException: Invalid object name 'TableName'
• The entity type 'EntityName' requires a primary key to be defined
• Unable to resolve service for type 'DbContext' while attempting migration

---

Understanding the Problem

Entity Framework Core uses migrations to track and apply database schema changes over time. When you make changes to your models, you create migrations that contain the necessary SQL commands to update the database schema. Migration errors typically occur when there’s a mismatch between your model definitions, migration files, and the actual database schema.

Typical .NET Project Structure:

MyEfCoreApp/
├── MyEfCoreApp.sln
├── src/
│   ├── MyEfCoreApp/
│   │   ├── Program.cs
│   │   ├── Startup.cs
│   │   ├── Controllers/
│   │   │   ├── HomeController.cs
│   │   │   └── UserController.cs
│   │   ├── Models/
│   │   │   ├── User.cs
│   │   │   └── Product.cs
│   │   ├── Data/
│   │   │   ├── ApplicationDbContext.cs
│   │   │   ├── Migrations/
│   │   │   │   ├── 20260108120000_InitialCreate.cs
│   │   │   │   └── ApplicationDbContextModelSnapshot.cs
│   │   │   └── SeedData.cs
│   │   ├── Services/
│   │   │   ├── IUserService.cs
│   │   │   └── UserService.cs
│   │   ├── MyEfCoreApp.csproj
│   │   └── appsettings.json
│   └── MyEfCoreApp.Tests/
│       ├── UnitTests.cs
│       └── MyEfCoreApp.Tests.csproj
├── packages/
└── bin/

---

Solution 1: Proper Migration Setup and Configuration

The most fundamental approach to prevent migration errors is to ensure proper EF Core setup and configuration.

❌ Without Proper Migration Setup:

// Data/ApplicationDbContext.cs - ❌ Missing migration configuration
using Microsoft.EntityFrameworkCore;

namespace MyEfCoreApp.Data
{
    public class ApplicationDbContext : DbContext
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
        {
        }

        public DbSet<User> Users { get; set; }
        public DbSet<Product> Products { get; set; }

        // ❌ Missing OnModelCreating configuration
        // ❌ Missing migration attributes
    }
}

✅ With Proper Migration Configuration:

Models/User.cs:

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

namespace MyEfCoreApp.Models
{
    [Table("Users")]
    public class User
    {
        [Key]
        public int Id { get; set; }

        [Required]
        [MaxLength(100)]
        public string Name { get; set; } = string.Empty;

        [Required]
        [MaxLength(255)]
        [EmailAddress]
        public string Email { get; set; } = string.Empty;

        public bool IsActive { get; set; } = true;

        public string? Role { get; set; }

        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

        public DateTime? UpdatedAt { get; set; }

        // ✅ Navigation property for related entities
        public virtual ICollection<UserProfile> Profiles { get; set; } = new List<UserProfile>();
    }
}

Models/UserProfile.cs:

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

namespace MyEfCoreApp.Models
{
    [Table("UserProfiles")]
    public class UserProfile
    {
        [Key]
        public int Id { get; set; }

        [Required]
        public int UserId { get; set; }

        [MaxLength(50)]
        public string? FirstName { get; set; }

        [MaxLength(50)]
        public string? LastName { get; set; }

        [MaxLength(255)]
        public string? Address { get; set; }

        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

        public DateTime? UpdatedAt { get; set; }

        // ✅ Navigation property back to User
        [ForeignKey("UserId")]
        public virtual User User { get; set; } = null!;
    }
}

Models/Product.cs:

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

namespace MyEfCoreApp.Models
{
    [Table("Products")]
    public class Product
    {
        [Key]
        public int Id { get; set; }

        [Required]
        [MaxLength(200)]
        public string Name { get; set; } = string.Empty;

        [MaxLength(1000)]
        public string? Description { get; set; }

        [Column(TypeName = "decimal(18,2)")]
        public decimal Price { get; set; }

        public int StockQuantity { get; set; } = 0;

        public bool IsActive { get; set; } = true;

        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

        public DateTime? UpdatedAt { get; set; }

        // ✅ Navigation property for related entities
        public virtual ICollection<OrderItem> OrderItems { get; set; } = new List<OrderItem>();
    }
}

Models/OrderItem.cs:

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

namespace MyEfCoreApp.Models
{
    [Table("OrderItems")]
    public class OrderItem
    {
        [Key]
        public int Id { get; set; }

        [Required]
        public int OrderId { get; set; }

        [Required]
        public int ProductId { get; set; }

        public int Quantity { get; set; } = 1;

        [Column(TypeName = "decimal(18,2)")]
        public decimal UnitPrice { get; set; }

        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

        // ✅ Foreign key relationships
        [ForeignKey("OrderId")]
        public virtual Order Order { get; set; } = null!;

        [ForeignKey("ProductId")]
        public virtual Product Product { get; set; } = null!;
    }
}

Models/Order.cs:

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

namespace MyEfCoreApp.Models
{
    [Table("Orders")]
    public class Order
    {
        [Key]
        public int Id { get; set; }

        [Required]
        public int UserId { get; set; }

        [Column(TypeName = "decimal(18,2)")]
        public decimal TotalAmount { get; set; }

        public string Status { get; set; } = "Pending";

        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

        public DateTime? UpdatedAt { get; set; }

        // ✅ Navigation properties
        [ForeignKey("UserId")]
        public virtual User User { get; set; } = null!;

        public virtual ICollection<OrderItem> OrderItems { get; set; } = new List<OrderItem>();
    }
}

Data/ApplicationDbContext.cs:

using Microsoft.EntityFrameworkCore;
using MyEfCoreApp.Models;

namespace MyEfCoreApp.Data
{
    public class ApplicationDbContext : DbContext
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
        {
        }

        // ✅ Define DbSets for all entities
        public DbSet<User> Users { get; set; }
        public DbSet<UserProfile> UserProfiles { get; set; }
        public DbSet<Product> Products { get; set; }
        public DbSet<Order> Orders { get; set; }
        public DbSet<OrderItem> OrderItems { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            // ✅ Configure entity relationships
            modelBuilder.Entity<User>(entity =>
            {
                entity.HasKey(e => e.Id);
                entity.Property(e => e.Name).IsRequired().HasMaxLength(100);
                entity.Property(e => e.Email).IsRequired().HasMaxLength(255);
                entity.HasIndex(e => e.Email).IsUnique();
                entity.Property(e => e.CreatedAt).HasDefaultValueSql("GETUTCDATE()");
            });

            modelBuilder.Entity<UserProfile>(entity =>
            {
                entity.HasKey(e => e.Id);
                entity.Property(e => e.FirstName).HasMaxLength(50);
                entity.Property(e => e.LastName).HasMaxLength(50);
                entity.Property(e => e.Address).HasMaxLength(255);
                entity.HasOne(d => d.User)
                      .WithMany(p => p.Profiles)
                      .HasForeignKey(d => d.UserId)
                      .OnDelete(DeleteBehavior.Cascade);
            });

            modelBuilder.Entity<Product>(entity =>
            {
                entity.HasKey(e => e.Id);
                entity.Property(e => e.Name).IsRequired().HasMaxLength(200);
                entity.Property(e => e.Description).HasMaxLength(1000);
                entity.Property(e => e.Price).HasColumnType("decimal(18,2)");
                entity.Property(e => e.CreatedAt).HasDefaultValueSql("GETUTCDATE()");
            });

            modelBuilder.Entity<Order>(entity =>
            {
                entity.HasKey(e => e.Id);
                entity.Property(e => e.Status).HasMaxLength(50);
                entity.Property(e => e.TotalAmount).HasColumnType("decimal(18,2)");
                entity.Property(e => e.CreatedAt).HasDefaultValueSql("GETUTCDATE()");
                entity.HasOne(d => d.User)
                      .WithMany(p => p.Orders)
                      .HasForeignKey(d => d.UserId)
                      .OnDelete(DeleteBehavior.Cascade);
            });

            modelBuilder.Entity<OrderItem>(entity =>
            {
                entity.HasKey(e => e.Id);
                entity.Property(e => e.UnitPrice).HasColumnType("decimal(18,2)");
                entity.Property(e => e.CreatedAt).HasDefaultValueSql("GETUTCDATE()");
                entity.HasOne(d => d.Order)
                      .WithMany(p => p.OrderItems)
                      .HasForeignKey(d => d.OrderId)
                      .OnDelete(DeleteBehavior.Cascade);
                entity.HasOne(d => d.Product)
                      .WithMany(p => p.OrderItems)
                      .HasForeignKey(d => d.ProductId)
                      .OnDelete(DeleteBehavior.Restrict);
            });

            base.OnModelCreating(modelBuilder);
        }

        public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
        {
            // ✅ Update timestamps before saving
            var entries = ChangeTracker.Entries()
                .Where(e => e.State == EntityState.Added || e.State == EntityState.Modified);

            foreach (var entry in entries)
            {
                if (entry.Entity is User user)
                {
                    if (entry.State == EntityState.Added)
                    {
                        user.CreatedAt = DateTime.UtcNow;
                    }
                    user.UpdatedAt = DateTime.UtcNow;
                }
                else if (entry.Entity is UserProfile profile)
                {
                    if (entry.State == EntityState.Added)
                    {
                        profile.CreatedAt = DateTime.UtcNow;
                    }
                    profile.UpdatedAt = DateTime.UtcNow;
                }
                else if (entry.Entity is Product product)
                {
                    if (entry.State == EntityState.Added)
                    {
                        product.CreatedAt = DateTime.UtcNow;
                    }
                    product.UpdatedAt = DateTime.UtcNow;
                }
                else if (entry.Entity is Order order)
                {
                    if (entry.State == EntityState.Added)
                    {
                        order.CreatedAt = DateTime.UtcNow;
                    }
                    order.UpdatedAt = DateTime.UtcNow;
                }
            }

            try
            {
                return await base.SaveChangesAsync(cancellationToken);
            }
            catch (DbUpdateException ex)
            {
                // ✅ Handle database update exceptions
                throw new InvalidOperationException("Database update failed", ex);
            }
            catch (Exception ex)
            {
                // ✅ Handle other database exceptions
                throw new InvalidOperationException("Database operation failed", ex);
            }
        }
    }
}

Program.cs (for .NET 6+):

using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using MyEfCoreApp.Data;

var builder = WebApplication.CreateBuilder(args);

// ✅ Add services to the container
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// ✅ Add Entity Framework with proper configuration
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection") 
    ?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));

var app = builder.Build();

// ✅ Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
    
    // ✅ Apply migrations automatically in development
    using (var scope = app.Services.CreateScope())
    {
        var context = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
        try
        {
            context.Database.Migrate();
        }
        catch (Exception ex)
        {
            var logger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred while migrating the database.");
        }
    }
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

---

Solution 2: Proper Migration Commands and Workflow

Learn the correct commands and workflow for managing Entity Framework migrations.

Common Migration Commands:

# ✅ Add a new migration
dotnet ef migrations add InitialCreate --project src/MyEfCoreApp --startup-project src/MyEfCoreApp

# ✅ Add migration with specific context
dotnet ef migrations add AddUserProfiles --context ApplicationDbContext

# ✅ Update database to latest migration
dotnet ef database update

# ✅ Update database to specific migration
dotnet ef database update MigrationName

# ✅ Remove last migration
dotnet ef migrations remove

# ✅ List all migrations
dotnet ef migrations list

# ✅ Script migration without applying
dotnet ef migrations script

# ✅ Get migration info
dotnet ef dbcontext info

PowerShell Commands (Package Manager Console):

# ✅ Add migration
Add-Migration InitialCreate

# ✅ Update database
Update-Database

# ✅ Remove migration
Remove-Migration

# ✅ Get migration history
Get-Migration

# ✅ Script migration
Script-Migration

---

Solution 3: Handle Migration Conflicts and Issues

Address common migration conflicts and issues that arise during development.

Data/Migrations/20260108120000_InitialCreate.cs:

using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace MyEfCoreApp.Data.Migrations
{
    /// <inheritdoc />
    public partial class InitialCreate : Migration
    {
        /// <inheritdoc />
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            // ✅ Create tables with proper constraints
            migrationBuilder.CreateTable(
                name: "Users",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Name = table.Column<string>(type: "nvarchar(100)", maxLength: 100, nullable: false),
                    Email = table.Column<string>(type: "nvarchar(255)", maxLength: 255, nullable: false),
                    IsActive = table.Column<bool>(type: "bit", nullable: false),
                    Role = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false, defaultValueSql: "GETUTCDATE()"),
                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Users", x => x.Id);
                });

            migrationBuilder.CreateTable(
                name: "Products",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Name = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: false),
                    Description = table.Column<string>(type: "nvarchar(1000)", maxLength: 1000, nullable: true),
                    Price = table.Column<decimal>(type: "decimal(18,2)", nullable: false),
                    StockQuantity = table.Column<int>(type: "int", nullable: false),
                    IsActive = table.Column<bool>(type: "bit", nullable: false),
                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false, defaultValueSql: "GETUTCDATE()"),
                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Products", x => x.Id);
                });

            migrationBuilder.CreateIndex(
                name: "IX_Users_Email",
                table: "Users",
                column: "Email",
                unique: true);
        }

        /// <inheritdoc />
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            // ✅ Drop tables in reverse order to handle foreign key constraints
            migrationBuilder.DropTable(
                name: "Products");

            migrationBuilder.DropTable(
                name: "Users");
        }
    }
}

Data/Migrations/20260108120001_AddUserProfiles.cs:

using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace MyEfCoreApp.Data.Migrations
{
    /// <inheritdoc />
    public partial class AddUserProfiles : Migration
    {
        /// <inheritdoc />
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            // ✅ Add new table with foreign key relationship
            migrationBuilder.CreateTable(
                name: "UserProfiles",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    UserId = table.Column<int>(type: "int", nullable: false),
                    FirstName = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: true),
                    LastName = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: true),
                    Address = table.Column<string>(type: "nvarchar(255)", maxLength: 255, nullable: true),
                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false, defaultValueSql: "GETUTCDATE()"),
                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_UserProfiles", x => x.Id);
                    table.ForeignKey(
                        name: "FK_UserProfiles_Users_UserId",
                        column: x => x.UserId,
                        principalTable: "Users",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateIndex(
                name: "IX_UserProfiles_UserId",
                table: "UserProfiles",
                column: "UserId");
        }

        /// <inheritdoc />
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            // ✅ Drop table that has foreign key relationships
            migrationBuilder.DropTable(
                name: "UserProfiles");
        }
    }
}

---

Solution 4: Resolve Migration Conflicts Between Developers

Handle scenarios where multiple developers create conflicting migrations.

Migration Conflict Resolution Strategy:

// ✅ When you encounter migration conflicts:

// 1. Pull the latest changes from the repository
// 2. Check if there are newer migrations than yours
// 3. If there are, you need to rebase your migration

// Example scenario:
// Developer A creates migration "AddProducts_20260108130000"
// Developer B creates migration "AddUsers_20260108130000" 
// Both based on the same previous migration

// Resolution:
// Developer B needs to rebase their migration:
// 1. dotnet ef migrations remove
// 2. dotnet ef migrations add AddUsers
// 3. dotnet ef database update

Data/Migrations/20260108130000_AddOrders.cs:

using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace MyEfCoreApp.Data.Migrations
{
    /// <inheritdoc />
    public partial class AddOrders : Migration
    {
        /// <inheritdoc />
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            // ✅ Add Orders table with foreign key to Users
            migrationBuilder.CreateTable(
                name: "Orders",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    UserId = table.Column<int>(type: "int", nullable: false),
                    TotalAmount = table.Column<decimal>(type: "decimal(18,2)", nullable: false),
                    Status = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: false),
                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false, defaultValueSql: "GETUTCDATE()"),
                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Orders", x => x.Id);
                    table.ForeignKey(
                        name: "FK_Orders_Users_UserId",
                        column: x => x.UserId,
                        principalTable: "Users",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            // ✅ Add OrderItems table with foreign keys to both Orders and Products
            migrationBuilder.CreateTable(
                name: "OrderItems",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    OrderId = table.Column<int>(type: "int", nullable: false),
                    ProductId = table.Column<int>(type: "int", nullable: false),
                    Quantity = table.Column<int>(type: "int", nullable: false),
                    UnitPrice = table.Column<decimal>(type: "decimal(18,2)", nullable: false),
                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false, defaultValueSql: "GETUTCDATE()")
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_OrderItems", x => x.Id);
                    table.ForeignKey(
                        name: "FK_OrderItems_Orders_OrderId",
                        column: x => x.OrderId,
                        principalTable: "Orders",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_OrderItems_Products_ProductId",
                        column: x => x.ProductId,
                        principalTable: "Products",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Restrict);
                });

            migrationBuilder.CreateIndex(
                name: "IX_OrderItems_OrderId",
                table: "OrderItems",
                column: "OrderId");

            migrationBuilder.CreateIndex(
                name: "IX_OrderItems_ProductId",
                table: "OrderItems",
                column: "ProductId");

            migrationBuilder.CreateIndex(
                name: "IX_Orders_UserId",
                table: "Orders",
                column: "UserId");
        }

        /// <inheritdoc />
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            // ✅ Drop tables in reverse order to handle foreign key constraints
            migrationBuilder.DropTable(
                name: "OrderItems");

            migrationBuilder.DropTable(
                name: "Orders");
        }
    }
}

---

Solution 5: Handle Database Schema Mismatches

Resolve issues when the database schema doesn’t match the model.

Services/DatabaseMigrationService.cs:

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using MyEfCoreApp.Data;
using System;
using System.Threading.Tasks;

namespace MyEfCoreApp.Services
{
    public interface IDatabaseMigrationService
    {
        Task<bool> MigrateDatabaseAsync();
        Task<bool> CheckDatabaseSchemaAsync();
        Task<bool> ResetDatabaseAsync();
        Task<string> GetMigrationStatusAsync();
    }

    public class DatabaseMigrationService : IDatabaseMigrationService
    {
        private readonly ApplicationDbContext _context;
        private readonly ILogger<DatabaseMigrationService> _logger;

        public DatabaseMigrationService(
            ApplicationDbContext context,
            ILogger<DatabaseMigrationService> logger)
        {
            _context = context;
            _logger = logger;
        }

        public async Task<bool> MigrateDatabaseAsync()
        {
            try
            {
                _logger.LogInformation("Starting database migration...");
                
                // ✅ Apply pending migrations
                await _context.Database.MigrateAsync();
                
                _logger.LogInformation("Database migration completed successfully.");
                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Database migration failed.");
                return false;
            }
        }

        public async Task<bool> CheckDatabaseSchemaAsync()
        {
            try
            {
                _logger.LogInformation("Checking database schema compatibility...");
                
                // ✅ Check if model has changed since database was created
                var pendingMigrations = await _context.Database.GetPendingMigrationsAsync();
                
                if (pendingMigrations.Any())
                {
                    _logger.LogWarning("Database schema is out of sync. Pending migrations: {Migrations}", 
                        string.Join(", ", pendingMigrations));
                    return false;
                }
                
                _logger.LogInformation("Database schema is up to date.");
                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error checking database schema.");
                return false;
            }
        }

        public async Task<bool> ResetDatabaseAsync()
        {
            try
            {
                _logger.LogInformation("Resetting database...");
                
                // ✅ Drop and recreate database
                await _context.Database.EnsureDeletedAsync();
                
                // ✅ Apply all migrations
                await _context.Database.MigrateAsync();
                
                _logger.LogInformation("Database reset completed successfully.");
                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Database reset failed.");
                return false;
            }
        }

        public async Task<string> GetMigrationStatusAsync()
        {
            try
            {
                var appliedMigrations = await _context.Database.GetAppliedMigrationsAsync();
                var pendingMigrations = await _context.Database.GetPendingMigrationsAsync();
                
                return $"Applied: {appliedMigrations.Count()}, Pending: {pendingMigrations.Count()}";
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting migration status.");
                return "Error retrieving migration status";
            }
        }

        // ✅ Additional utility methods
        public async Task<bool> SeedDataAsync()
        {
            try
            {
                _logger.LogInformation("Seeding initial data...");
                
                // ✅ Check if data already exists
                if (await _context.Users.AnyAsync())
                {
                    _logger.LogInformation("Data already seeded.");
                    return true;
                }
                
                // ✅ Add seed data
                var users = new[]
                {
                    new Models.User { Name = "John Doe", Email = "john@example.com", IsActive = true, Role = "Admin" },
                    new Models.User { Name = "Jane Smith", Email = "jane@example.com", IsActive = true, Role = "User" },
                    new Models.User { Name = "Bob Johnson", Email = "bob@example.com", IsActive = false, Role = "User" }
                };
                
                await _context.Users.AddRangeAsync(users);
                await _context.SaveChangesAsync();
                
                _logger.LogInformation("Data seeding completed successfully.");
                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Data seeding failed.");
                return false;
            }
        }

        public async Task<bool> ValidateModelCompatibilityAsync()
        {
            try
            {
                _logger.LogInformation("Validating model compatibility...");
                
                // ✅ Try to create a simple query to test model compatibility
                var userCount = await _context.Users.CountAsync();
                
                _logger.LogInformation("Model compatibility validated. User count: {Count}", userCount);
                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Model compatibility validation failed.");
                return false;
            }
        }
    }
}

---

Working Code Examples

Complete .NET Application with Proper EF Migration Setup:

// Program.cs
using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using MyEfCoreApp.Data;
using MyEfCoreApp.Services;

var builder = WebApplication.CreateBuilder(args);

// ✅ Add services to the container
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// ✅ Add Entity Framework
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection") 
    ?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));

// ✅ Add custom services
builder.Services.AddScoped<IDatabaseMigrationService, DatabaseMigrationService>();

var app = builder.Build();

// ✅ Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
    
    // ✅ Handle migrations in development
    using (var scope = app.Services.CreateScope())
    {
        var migrationService = scope.ServiceProvider.GetRequiredService<IDatabaseMigrationService>();
        
        try
        {
            // ✅ Check and apply migrations
            var schemaUpToDate = await migrationService.CheckDatabaseSchemaAsync();
            if (!schemaUpToDate)
            {
                await migrationService.MigrateDatabaseAsync();
            }
            
            // ✅ Seed initial data
            await migrationService.SeedDataAsync();
        }
        catch (Exception ex)
        {
            var logger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred while migrating or seeding the database.");
        }
    }
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

Controller with Proper EF Integration:

// Controllers/UserController.cs
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MyEfCoreApp.Data;
using MyEfCoreApp.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace MyEfCoreApp.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class UserController : ControllerBase
    {
        private readonly ApplicationDbContext _context;

        public UserController(ApplicationDbContext context)
        {
            _context = context;
        }

        [HttpGet]
        public async Task<ActionResult<IEnumerable<User>>> GetUsers()
        {
            try
            {
                var users = await _context.Users.ToListAsync();
                return Ok(users);
            }
            catch (Exception ex)
            {
                return StatusCode(500, new { message = "Error retrieving users", error = ex.Message });
            }
        }

        [HttpGet("{id}")]
        public async Task<ActionResult<User>> GetUser(int id)
        {
            try
            {
                var user = await _context.Users.FindAsync(id);
                
                if (user == null)
                {
                    return NotFound();
                }
                
                return Ok(user);
            }
            catch (Exception ex)
            {
                return StatusCode(500, new { message = "Error retrieving user", error = ex.Message });
            }
        }

        [HttpPost]
        public async Task<ActionResult<User>> CreateUser(User user)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(user.Name) || string.IsNullOrWhiteSpace(user.Email))
                {
                    return BadRequest("Name and email are required");
                }

                _context.Users.Add(user);
                await _context.SaveChangesAsync();

                return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);
            }
            catch (Exception ex)
            {
                return StatusCode(500, new { message = "Error creating user", error = ex.Message });
            }
        }

        [HttpPut("{id}")]
        public async Task<IActionResult> UpdateUser(int id, User user)
        {
            try
            {
                if (id != user.Id)
                {
                    return BadRequest("ID mismatch");
                }

                var existingUser = await _context.Users.FindAsync(id);
                if (existingUser == null)
                {
                    return NotFound();
                }

                existingUser.Name = user.Name;
                existingUser.Email = user.Email;
                existingUser.IsActive = user.IsActive;
                existingUser.Role = user.Role;
                existingUser.UpdatedAt = DateTime.UtcNow;

                await _context.SaveChangesAsync();
                return NoContent();
            }
            catch (Exception ex)
            {
                return StatusCode(500, new { message = "Error updating user", error = ex.Message });
            }
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteUser(int id)
        {
            try
            {
                var user = await _context.Users.FindAsync(id);
                if (user == null)
                {
                    return NotFound();
                }

                _context.Users.Remove(user);
                await _context.SaveChangesAsync();
                return NoContent();
            }
            catch (Exception ex)
            {
                return StatusCode(500, new { message = "Error deleting user", error = ex.Message });
            }
        }

        [HttpGet("migration-status")]
        public async Task<ActionResult<string>> GetMigrationStatus()
        {
            try
            {
                var appliedMigrations = await _context.Database.GetAppliedMigrationsAsync();
                var pendingMigrations = await _context.Database.GetPendingMigrationsAsync();
                
                return Ok(new
                {
                    Applied = appliedMigrations,
                    Pending = pendingMigrations,
                    Status = $"Applied: {appliedMigrations.Count()}, Pending: {pendingMigrations.Count()}"
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new { message = "Error getting migration status", error = ex.Message });
            }
        }
    }
}

Unit Test Example:

// MyEfCoreApp.Tests/UnitTests.cs
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using MyEfCoreApp.Data;
using MyEfCoreApp.Models;
using MyEfCoreApp.Services;
using System;
using System.Linq;
using System.Threading.Tasks;

namespace MyEfCoreApp.Tests
{
    [TestClass]
    public class EntityFrameworkMigrationTests
    {
        private ApplicationDbContext _context;
        private DatabaseMigrationService _migrationService;

        [TestInitialize]
        public void Setup()
        {
            var services = new ServiceCollection();
            
            // ✅ Use in-memory database for testing
            services.AddDbContext<ApplicationDbContext>(options =>
                options.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()));
            
            services.AddScoped<IDatabaseMigrationService, DatabaseMigrationService>();
            
            var serviceProvider = services.BuildServiceProvider();
            _context = serviceProvider.GetRequiredService<ApplicationDbContext>();
            _migrationService = serviceProvider.GetRequiredService<DatabaseMigrationService>();
        }

        [TestMethod]
        public async Task MigrationService_MigrateDatabase_Successfully()
        {
            // ✅ Act
            var result = await _migrationService.MigrateDatabaseAsync();

            // ✅ Assert
            Assert.IsTrue(result);
        }

        [TestMethod]
        public async Task MigrationService_CheckDatabaseSchema_UpToDate()
        {
            // ✅ Arrange - First migrate the database
            await _migrationService.MigrateDatabaseAsync();

            // ✅ Act
            var result = await _migrationService.CheckDatabaseSchemaAsync();

            // ✅ Assert
            Assert.IsTrue(result);
        }

        [TestMethod]
        public async Task DbContext_CanCreateAndRetrieveUser()
        {
            // ✅ Arrange
            var user = new User 
            { 
                Name = "Test User", 
                Email = "test@example.com", 
                IsActive = true 
            };

            // ✅ Act
            _context.Users.Add(user);
            await _context.SaveChangesAsync();

            var retrievedUser = await _context.Users.FirstOrDefaultAsync(u => u.Email == "test@example.com");

            // ✅ Assert
            Assert.IsNotNull(retrievedUser);
            Assert.AreEqual("Test User", retrievedUser.Name);
        }

        [TestMethod]
        public async Task DbContext_ModelCompatibility_Valid()
        {
            // ✅ Act
            var result = await _migrationService.ValidateModelCompatibilityAsync();

            // ✅ Assert
            Assert.IsTrue(result);
        }

        [TestMethod]
        public async Task DbContext_SeedData_Works()
        {
            // ✅ Act
            var result = await _migrationService.SeedDataAsync();

            // ✅ Assert
            Assert.IsTrue(result);

            // ✅ Verify data was seeded
            var userCount = await _context.Users.CountAsync();
            Assert.IsTrue(userCount > 0);
        }

        [TestMethod]
        public async Task DbContext_PendingMigrations_EmptyAfterMigration()
        {
            // ✅ Arrange - Migrate database
            await _migrationService.MigrateDatabaseAsync();

            // ✅ Act
            var pendingMigrations = await _context.Database.GetPendingMigrationsAsync();

            // ✅ Assert
            Assert.AreEqual(0, pendingMigrations.Count());
        }

        [TestMethod]
        public async Task DbContext_AppliedMigrations_NotEmptyAfterMigration()
        {
            // ✅ Arrange - Migrate database
            await _migrationService.MigrateDatabaseAsync();

            // ✅ Act
            var appliedMigrations = await _context.Database.GetAppliedMigrationsAsync();

            // ✅ Assert
            Assert.IsTrue(appliedMigrations.Any());
        }

        [TestCleanup]
        public void Cleanup()
        {
            _context?.Dispose();
        }
    }
}

---

Best Practices for EF Migrations

1. Always Backup Before Major Migrations

// ✅ Create database backup before running destructive migrations
// Use SQL Server backup tools or scripts

2. Test Migrations in Staging Environment

// ✅ Always test migrations in a staging environment before production
// Use similar data and configurations to production

3. Use Descriptive Migration Names

# ✅ Good migration names
dotnet ef migrations add AddUserProfilesTable
dotnet ef migrations add AddOrderStatusField
dotnet ef migrations add CreateIndexesForPerformance

4. Handle Data Migration Carefully

// ✅ When adding new fields that shouldn't be null, provide default values
protected override void Up(MigrationBuilder migrationBuilder)
{
    migrationBuilder.AddColumn<string>(
        name: "NewField",
        table: "Users",
        type: "nvarchar(100)",
        nullable: false,
        defaultValue: "");
}

5. Use Migration Scripts for Production

# ✅ Generate migration script for DBA review
dotnet ef migrations script --output migration.sql

6. Monitor Migration Execution

// ✅ Log migration execution and monitor for errors
public async Task<bool> MigrateDatabaseAsync()
{
    _logger.LogInformation("Starting migration at {Time}", DateTime.UtcNow);
    try
    {
        await _context.Database.MigrateAsync();
        _logger.LogInformation("Migration completed successfully at {Time}", DateTime.UtcNow);
        return true;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Migration failed at {Time}", DateTime.UtcNow);
        return false;
    }
}

---

Debugging Steps

Step 1: Check Migration Files

# ✅ Verify migration files exist and are properly generated
ls Data/Migrations/

Step 2: Compare Model with Database

// ✅ Use EF commands to check model differences
// dotnet ef dbcontext info
// dotnet ef migrations list

Step 3: Examine Migration Content

// ✅ Look at the generated migration code for errors
// Check Up() and Down() methods for correctness

Step 4: Test Connection

// ✅ Verify database connection works
// Test with a simple query

Step 5: Apply Migrations Gradually

# ✅ Apply migrations one by one to isolate issues
dotnet ef database update --target MigrationName

Step 6: Use Verbose Logging

# ✅ Enable verbose logging for detailed error information
dotnet ef database update --verbose

---

Common Mistakes to Avoid

1. Ignoring Migration Conflicts

// ❌ Not resolving migration conflicts properly
// Always coordinate with team members on migration timing

2. Skipping Migrations in Production

// ❌ Never skip migrations in production
// Always apply migrations through proper deployment process

3. Modifying Generated Migration Files

// ❌ Don't modify generated migration files unless absolutely necessary
// If you must, document the changes thoroughly

4. Not Testing Rollbacks

// ❌ Always test migration rollback capability
// Ensure Down() methods work correctly

5. Poor Migration Naming

# ❌ Bad migration names
dotnet ef migrations add Migration1  # ❌ Too generic
dotnet ef migrations add Update     # ❌ Too vague

# ✅ Good migration names
dotnet ef migrations add AddUserProfileTable  # ✅ Descriptive
dotnet ef migrations add AddUserEmailIndex   # ✅ Specific

---

Performance Considerations

1. Batch Large Data Migrations

// ✅ For large data migrations, process in batches
protected override void Up(MigrationBuilder migrationBuilder)
{
    // Process large data updates in batches to avoid timeouts
    migrationBuilder.Sql(@"
        UPDATE Users 
        SET NewField = 'DefaultValue' 
        WHERE NewField IS NULL
        OPTION (MAXDOP 1, LOOP JOIN)");
}

2. Use Raw SQL for Complex Operations

// ✅ For complex operations, use raw SQL in migrations
protected override void Up(MigrationBuilder migrationBuilder)
{
    migrationBuilder.Sql(@"
        INSERT INTO UserProfiles (UserId, FirstName, LastName)
        SELECT Id, LEFT(Name, CHARINDEX(' ', Name + ' ') - 1), 
               CASE WHEN CHARINDEX(' ', Name) > 0 
                    THEN RIGHT(Name, LEN(Name) - CHARINDEX(' ', Name)) 
                    ELSE '' END
        FROM Users 
        WHERE Id NOT IN (SELECT UserId FROM UserProfiles)");
}

3. Consider Migration Timeout

// ✅ Set appropriate timeout for long-running migrations
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(connectionString, sqlOptions =>
        {
            sqlOptions.CommandTimeout(300); // 5 minutes
        }));
}

---

Security Considerations

1. Secure Connection Strings

// ✅ Use secure connection string management
// Store in Azure Key Vault, AWS Secrets Manager, or similar

2. Validate Migration Scripts

// ✅ Review migration scripts before applying to production
// Especially those containing raw SQL

3. Limit Database Permissions

// ✅ Use principle of least privilege for database accounts
// Limit migration account permissions appropriately

4. Audit Migration Changes

// ✅ Log all migration activities for security auditing
// Track who applied migrations and when

---

Testing Migration Scenarios

1. Test Migration Application

[TestMethod]
public async Task Migration_Application_Works()
{
    var migrationService = new DatabaseMigrationService(context, logger);
    var result = await migrationService.MigrateDatabaseAsync();
    Assert.IsTrue(result);
}

2. Test Migration Rollback

[TestMethod]
public async Task Migration_Rollback_Works()
{
    // Apply migration, then rollback to test Down() method
    // This is harder to test automatically, often manual verification needed
}

3. Test Model Compatibility

[TestMethod]
public async Task Model_Compatibility_Valid()
{
    // Test that the model can interact with the migrated database
    var user = new User { Name = "Test", Email = "test@example.com" };
    context.Users.Add(user);
    await context.SaveChangesAsync();
    
    var retrieved = await context.Users.FirstAsync(u => u.Id == user.Id);
    Assert.IsNotNull(retrieved);
}

4. Test Data Integrity

[TestMethod]
public async Task Data_Integrity_Maintained()
{
    // Test that data remains intact after migrations
    // Verify foreign key relationships still work
    // Check that indexes are properly created
}

---

Alternative Solutions

1. Use Database Projects

-- ✅ Consider using SQL Server Database Projects for complex schema management
-- This provides additional tools for schema versioning and deployment

2. Manual Database Updates

-- ❌ Avoid manual database updates when using EF migrations
-- Stick to EF migration system for consistency

3. Third-Party Migration Tools

# ✅ Consider tools like Flyway or Liquibase for advanced migration scenarios
# Though EF migrations are usually sufficient for most .NET applications

---

Migration Checklist

• Verify Entity Framework packages are installed and up-to-date
• Ensure DbContext is properly configured with OnModelCreating
• Check that all entities have proper key configurations
• Verify connection string is correct and accessible
• Test migration commands in development environment
• Review generated migration files for accuracy
• Plan migration deployment to production
• Prepare rollback strategy for failed migrations
• Test migration on staging environment before production
• Document migration process and procedures

---

Conclusion

The ‘Entity Framework Migration Not Working’ error is a common but preventable .NET issue that occurs when EF migrations fail to execute properly. By following the solutions provided in this guide—implementing proper migration setup, using correct migration commands, handling conflicts, and following best practices—you can effectively prevent and resolve this error in your .NET applications.

The key is to understand Entity Framework’s migration mechanisms, implement proper database schema management patterns, use modern .NET features correctly, and maintain clean, well-organized code. With proper EF migration management, your .NET applications will maintain consistent database schemas and avoid common runtime errors.

Remember to test your changes thoroughly, follow .NET best practices for Entity Framework, implement proper error handling, and regularly review your migration procedures to ensure your applications maintain the best possible architecture and avoid common EF migration errors.