Software Development Updates

Managing the database schemas of a growing application is a challenging task. If you are manually handling all the changes, then it is not only time-consuming but also prone to errors, leading to numerous inconsistencies. So, what’s the solution? Using the EF Core migrations feature, you can easily keep the database schema in sync with your app’s data model without risking the loss of existing data. A reliable .NET development company can offer a high-quality app by leveraging such innovative solutions. They can effectively use Entity Framework Core migrations to automate the migration process, which simplifies database management. 

Read this article to learn more about EF Core migrations and how they work in real-life scenarios.

1. EF Core Migration Overview

EF Core migration synchronizes the database schema with the EF Core model, ensuring its preservation.

You build the EF Core model using the EF Core API by applying Data Annotation attributes to your entity classes and configuring the Fluent API in the DbContext class.

The EF Core migrations API creates or updates the database schema based on the changes made to the EF Core model. By running migration commands, you can ensure that your database schema remains up-to-date whenever you make modifications to the domain classes. 

You can run EF Core migrations, which are a set of commands, using either .NET Core CLI or Package Manager Console. As your app evolves with time, the EF Core migrations allow developers to continuously update the database schema through various versions.

• Migrations simplify how you apply or revert database changes, ensuring that your application’s version upgrades proceed seamlessly and that you preserve important data.
• SQL Scripts are essential for updating the database schema. The EF Core migrations automatically generate and execute these scripts, automatically you to update your data loss or the burden of manually writing scripts. 

There are two steps in the EF Core migration process; creating a migration and applying it. The migration process ensures that the database schema aligns perfectly with the database model and reflects every change in the model in the database.

It includes configuration changes, modifications to the properties of the model class, and the addition or removal of properties from the context class, among other updates.

2. Why are EF Core Migrations Important?

Let us explore the reasons why you should use EF Core Migrations for database management: 

• Easy Database Management: EF Core migrations enable you to manage database changes across multiple versions. This makes it easy to manage the database that keeps evolving with the growing application. 
• Database Schema Tracking: The database evolves alongside the application. With EF Core migration, you can keep track of all the changes made to the schema over time and manage them effectively. 
• Automation: The database schema is created automatically when you use EF Core migrations. This eliminates the need to manually write SQL scripts or handle the database management processes. 
• Maintaining Database Consistency: EF Core migrations manage the state of the database, ensuring that all instances remain consistent. By eliminating inconsistencies, the database is less prone to errors.

3. Steps to Set Up EF Core Migrations

Let’s take a look at how to install the EF Core packages for migration.

3.1 Install EF Core Packages

Search for the EF Core NuGet packages required for the project and install them on your system as shown below:

dotnet add package Microsoft.EntityFrameworkCore.Tools

dotnet add package Microsoft.EntityFrameworkCore.SqlServer # Replace with your database provider

3.2 Create the DbContext

Now, define a C# class representing a table in the database to create an entity model in the Entity Framework Core. The columns of the table and the properties’ class are corresponding. Use navigation properties to establish their relationships. EF Core utilizes these entity models to map between the app code and the database schema.

public class ProductContext : DbContext
  {
      public DbSet Products { get; set; }
      public DbSet Categories { get; set; }
      protected override void OnConfiguring(
          DbContextOptionsBuilder optionsBuilder)
      {
          optionsBuilder.UseSqlServer("YourConnectionString");
      }
  }

Note: The database connection can also be configured in Program.cs.

services.AddDbContext(options =>
options.UseSqlServer("YourConnectionString"));

3.3 Define Entity Models

Run the following code to create classes that represent the tables from your database.

public class Product
{
    public int ProductId { get; set; }
    public string Name { get; set; }
    public int CategoryId { get; set; }
    public virtual Category Category { get; set; }
}

3.4 Define Entity Configuration

EF Core’s entity configurations assist you in mapping your application’s domain models to the database schema. Properties such as table mappings, relationships, constraints, and primary keys are specified in these configurations.

You can define it either by using the Fluent API within the DbContext’s OnModelCreating method or by applying Data Annotations directly to the model classes. Implementing IEntityTypeConfiguration<TEntity> allows you to separate the configurations into different classes, providing better organization and maintainability. 

The entity configurations can be defined as shown below:

internal class ProductConfigurations: IEntityTypeConfiguration
{
    public void Configure(EntityTypeBuilder builder)
    {
        builder.HasKey(e => e.ProductId);
        builder.Property(e => e.Name)
            .HasMaxLength(100)
            .IsUnicode();
        builder.HasOne(d => d.Category).WithMany(p => p.Products)
            .HasForeignKey(d => d.CategoryId)
            .OnDelete(DeleteBehavior.ClientSetNull);
    }
}

Register it under OnModelCreating as given below:

protected override void OnModelCreating(ModelBuilder builder)
{
    builder.ApplyConfigurationsFromAssembly(typeof(DbContext).Assembly);
    base.OnModelCreating(builder);
}

4. How to Add a New Migration?

Running the Add-Migration command in Entity Framework allows you to scaffold a migration script. If any change is implemented to the data model, the migration script will reflect it. The difference between the last applied migration and the current data model is illustrated in this script.

Let’s understand how it works: 

• The process begins by comparing the current state of your data model with the last applied migration. If there are no previous migrations, the script will compare the current state of the data model with its initial state. 
• If the script detects any differences, it will create a migration file using two separate methods: 
• Up(): Defines the changes to be applied, such as creating a table or adding a column. 
• Down(): Defines how the changes can be rolled back, such as removing the table or deleting the column.

There are two ways to create a new migration: 

1. Open the Package Manager Console and run the “add-migration <Name>” command 
2. Open the .NET CLI and execute the “dotnet ef migrations add <MigrationName>” code.

If a new migration is added, then you can see the output shown in the image below:

You can also see a new folder named Migrations is added.

5. How to Update the Database to the Latest Migration?

You can execute all the pending migrations to the database by using the update-database command from Entity Framework. This command also runs the migration scripts created by the add-migration command to ensure that the application’s current model matches the database schema. You can use either the CLI or Package Manager Console to execute this command.

PM> update-database
CLI -> dotnet ef database update

6. How to Modify the Data Model and Add a New Migration?

To create a new migration file in EF Core, run the add-migration “new migration name” command. This file will contain the code needed to update the database schema based on the changes made to the DbContext or model. 

The team reflects all the modifications in the database. Once you apply these changes to the DbContext or your model, run the following command along with the update-database command to create a new migration. The code below shows the way to add properties to the Product model.

Now, run add-migration “ModifiedProductEntity”.

dotnet ef migrations add “ModifiedProductEntity”

One more file will be added to the Migrations folder once you run the above code.

To update it, run the same update-database command.

PM> update-database

7. Getting a List of Migration

To execute the Get-Migration command in the EF Core framework, you can obtain a list of all the EF Core migrations implemented in the database, as well as those available in the project. This command helps verify the existing migrations and those applied in the past.

PM> Get-Migration
CLI>dotnet ef migrations list

8. How to Remove a Migration?

If you add a migration by mistake or need to remove a migration that is no longer required in Entity Framework Core, you can use the remove-migration command. However, this command will only work if the migration hasn’t been applied using the update-database command. If that condition is fulfilled, then the remove-migration command allows you to withdraw the most recently added migration.

PM> remove-migration
CLI>dotnet ef migrations remove

Once the command is executed, you can see that the file of the recently added migration is removed.

If we run the command to get migrations, we can see that ModifiedProductEntity is now not getting listed.

9. How to Revert the Database to a Specific Migration?

The EF Core framework’s update-database <migration-name> command can apply migrations up to a specific migration. The database schema is brought to the state of the specified schema by rolling forward or backward. This helps you revert to a selected applied update or a previous migration.

PM>update-database 
CLI>dotnet ef database update 

10. Conclusion

EF Core migrations make it easy to handle changes in the database schema of your app. In this article, we explored how to use it to create, update, remove, and revert a migration using EF Core migrations. Many developers still prefer to write SQL Scripts and perform the migration process manually. However, using Entity Framework Core Migrations not only automates the entire migration process but also allows you to review it to identify potential issues. 

Once you get a working understanding of the concept, you can easily benefit from it in many ways. In case of any query, feel free to contact our experts.