MSDN Documentation

Home > Entity Framework Core > Database Management

Entity Framework Core Database Management

This document provides a comprehensive overview of managing your databases with Entity Framework Core (EF Core). EF Core offers powerful tools and patterns to interact with and control your database schema, data, and migrations.

Understanding Database Management in EF Core

EF Core simplifies database management through several key features:

  • Migrations: A powerful feature that allows you to evolve your database schema over time as your application's data model changes.
  • Database Creation: EF Core can automatically create your database if it doesn't exist, based on your model.
  • Database Seeding: Populate your database with initial or test data.
  • Database Providers: EF Core supports various database systems (SQL Server, PostgreSQL, SQLite, MySQL, etc.) through provider packages.

EF Core Migrations

Migrations are a fundamental part of database management with EF Core. They allow you to:

  • Track schema changes.
  • Apply changes to the database in a controlled manner.
  • Roll back changes if necessary.
  • Deploy database changes alongside your application code.

Creating a Migration

To create a new migration, open a Package Manager Console or a terminal in your project directory and run the following command:


.NET CLI:
dotnet ef migrations add InitialCreate

Package Manager Console:
Add-Migration InitialCreate

This command analyzes your EF Core model and generates C# code representing the changes needed to create or update your database schema. The first migration is typically named InitialCreate and includes logic to create the initial tables.

Applying Migrations

Once you have created migrations, you can apply them to your database:


.NET CLI:
dotnet ef database update

Package Manager Console:
Update-Database

This command applies all pending migrations to the target database, bringing its schema up to date with your EF Core model.

Reverting Migrations

You can also revert a migration:


.NET CLI:
dotnet ef migrations remove

Package Manager Console:
Remove-Migration

To revert to a specific migration:


.NET CLI:
dotnet ef database update MigrationName

Package Manager Console:
Update-Database MigrationName

Database Seeding

EF Core allows you to seed your database with initial data using the HasData method in your model configuration. This is particularly useful for populating lookup tables or providing default values.


protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Category>().HasData(
        new Category { CategoryId = 1, Name = "Books" },
        new Category { CategoryId = 2, Name = "Electronics" },
        new Category { CategoryId = 3, Name = "Home Goods" }
    );
}

After adding seed data, you'll typically create a new migration to include this data in your database updates.

Provider-Specific Database Management

While EF Core provides a consistent API, the underlying database operations and specific management tasks can vary depending on the database provider you are using. For example, SQL Server might use different tools for schema comparison than PostgreSQL.

  • SQL Server: Often managed using SQL Server Management Studio (SSMS), Azure Data Studio, or command-line tools like sqlcmd.
  • PostgreSQL: Managed with tools like pgAdmin or the command-line psql.
  • SQLite: Typically managed with tools like DB Browser for SQLite.

Refer to the documentation for your specific database provider for more advanced management techniques.

Common Database Management Tasks

  • Creating Databases: EF Core can create databases automatically, or you can manage their creation manually.
  • Deleting Databases: Use the Drop-Database cmdlet or dotnet ef database drop to remove a database.
  • Inspecting Schema: Use database tools to view the current schema and compare it with your EF Core model.
  • Performance Tuning: Implement indexing strategies and optimize queries for better performance.

By leveraging EF Core's database management features, you can streamline your development workflow and ensure your database schema remains consistent and up-to-date with your application's evolving needs.