Deep Dive into Entity Framework Core (EF Core) Migrations

10 March 2018

Entity Framework Core (EF Core) has quickly become one of the most popular Object-Relational Mapping (ORM) frameworks for .NET Core, allowing developers to interact with databases using C# code. One of the key features that EF Core provides is its migration system, which helps manage changes to the database schema over time. In this post, we’ll take a deep dive into EF Core migrations, explaining how they work, how to create and apply migrations, and best practices to follow.

What are Migrations in EF Core?

Migrations in EF Core allow you to evolve your database schema as your application changes. Instead of manually modifying the database structure (such as adding or removing tables or columns), EF Core provides a way to generate these changes automatically from your code.

When you change your entity classes or the context that manages them, migrations allow you to keep your database schema synchronized with your models. This is a crucial part of maintaining the integrity and versioning of the database as your application evolves.

Creating a Migration

To create a migration, you’ll use the dotnet ef command line tool. Before running the command, ensure your project has the required dependencies to support migrations.

Install EF Core CLI tools (if you haven’t already): dotnet tool install --global dotnet-ef
Create your first migration: After adding, modifying, or removing entities or properties in your DbContext, you can create a migration by running: dotnet ef migrations add InitialCreate Here, InitialCreate is the name of the migration. You should name it something descriptive to reflect the changes you’ve made (e.g., AddProductTable if you added a new table). This command will generate a new migration file in the Migrations folder of your project. The file will contain two methods: Up() and Down().
- Up(): This method defines the changes that should be applied to the database (like creating a table, adding a column, etc.).
- Down(): This method defines how to reverse the changes made in Up(). It should revert all changes that were made in the migration.

Applying Migrations to the Database

After creating the migration, you need to apply it to the database to update the schema. This is done using the dotnet ef database update command.

Apply migration: dotnet ef database update Running this command will apply the latest migration and update your database accordingly. If you have multiple migrations, it will apply them in the order they were created.
Targeting a specific migration: You can also apply a specific migration by specifying its name: dotnet ef database update InitialCreate This allows you to apply a specific migration if you want to, rather than always applying the latest one.

Reverting Migrations

Sometimes, you may want to revert a migration (for example, if something went wrong or you need to backtrack). EF Core provides an easy way to revert the last applied migration.

Reverting the last migration: dotnet ef database update <PreviousMigrationName> For example, if your last migration was InitialCreate and you want to revert it, you can specify the migration name before that to undo the changes. If you’re reverting to the initial state, you can use 0 to indicate no migrations: dotnet ef database update 0 This command will undo all migrations and restore your database to its original state.

Best Practices for Using Migrations

Create migrations frequently: Don’t wait too long before creating migrations. It’s better to create a migration after a few meaningful changes to your models, rather than trying to generate one massive migration at the end. This will help avoid conflicts and make it easier to track changes over time.
Use descriptive names: Give your migrations descriptive names that reflect the changes made. This will make it easier to understand what each migration is doing at a glance.
Version control for migrations: Always commit migrations to your source control system (e.g., Git). This allows other developers to pull the latest migrations and keep their local databases in sync with changes.
Handling data changes: If migrations require data changes (for example, changing column types or renaming columns), be mindful of potential data loss or corruptions. In such cases, you might need to manually adjust the migration code or use raw SQL.
Use Script-Migration for complex changes: For complex migrations that require SQL scripts (e.g., renaming columns, modifying constraints), use the dotnet ef migrations script command to generate a SQL script to be run manually on your production database.

Conclusion

EF Core migrations are an essential part of any database-driven application, allowing you to manage schema changes seamlessly without risking data loss. By creating, applying, and reverting migrations, you can keep your database up-to-date as your application evolves.

Understanding how migrations work and using them effectively will save you time and prevent headaches as you scale your application. If you’re not using migrations yet, I strongly recommend giving them a try in your next .NET Core project. Stay tuned for more .NET Core tips and best practices!