Topic 15136 min readStructured Tutorial

Entity Framework Core Code First Approach

Quick Answer

Entity Framework Core's Code First approach allows developers to define database schemas using C# classes and then generate the database automatically. This approach is ideal for developers who prefer to start with the domain model and let EF Core handle database creation and migrations.

Learning Objectives

Explain the purpose of Code First Approach in a practical learning context.
Identify the main ideas, terms, and decisions involved in Code First Approach.
Apply Code First Approach in a simple real-world scenario or practice task.

Introduction

Entity Framework Core (EF Core) is a popular Object-Relational Mapper (ORM) for .NET developers.

The Code First approach lets you define your database schema using C# classes, enabling a model-driven development workflow.

This tutorial will guide you through the basics of Code First, including model creation, DbContext setup, and database migrations.

Code First lets you focus on your domain model and let EF Core handle the database.

What is the Code First Approach?

Code First is one of the development workflows in EF Core where you start by writing C# classes that represent your data model.

EF Core then uses these classes to generate the database schema automatically.

This approach is especially useful when you want full control over your domain model without designing the database upfront.

Define POCO (Plain Old CLR Objects) classes representing entities.
Configure relationships and constraints using data annotations or Fluent API.
Generate and update the database schema via migrations.

Setting Up Your Project for Code First

To start with Code First, create a new .NET project and add the EF Core packages.

You need to install the main EF Core package and a database provider, such as SQL Server or SQLite.

Install Microsoft.EntityFrameworkCore package.
Install a database provider package like Microsoft.EntityFrameworkCore.SqlServer.
Create your DbContext class inheriting from EF Core's DbContext.

Common EF Core Packages for Code First
Package	Purpose
Microsoft.EntityFrameworkCore	Core EF functionality
Microsoft.EntityFrameworkCore.SqlServer	SQL Server database provider
Microsoft.EntityFrameworkCore.Tools	Tools for migrations and scaffolding

Defining Your Data Model

Create C# classes that represent your entities. These classes should have properties corresponding to table columns.

You can use data annotations or Fluent API to configure entity properties, keys, and relationships.

Use [Key] attribute to specify primary keys if not named conventionally.
Use [Required] to enforce non-nullable columns.
Configure one-to-many, many-to-many relationships using navigation properties.

Example Entity Class

Here is a simple example of a Product entity class with annotations.

Creating the DbContext

The DbContext class manages entity objects during runtime, including querying and saving data.

You define DbSet<TEntity> properties for each entity type you want to include in the model.

Inherit from DbContext.
Override OnConfiguring or use dependency injection to configure the database connection.
Define DbSet properties for each entity.

Applying Migrations and Creating the Database

Migrations allow you to incrementally update your database schema as your model changes.

You create migrations using EF Core CLI or Package Manager Console commands and then apply them to the database.

Use 'Add-Migration' command to scaffold a new migration.
Use 'Update-Database' command to apply migrations to the database.
Migrations keep your database schema in sync with your model classes.

Code First Example: Product Catalog

Let's look at a practical example defining a Product entity and a DbContext, then applying migrations.

Practical Example

This class defines a Product entity with a primary key, a required Name, and a Price.

This DbContext configures a SQL Server connection and includes a DbSet for Products.

These commands create the initial migration and update the database schema accordingly.

Examples

Product Entity Class

using System.ComponentModel.DataAnnotations;

public class Product
{
    [Key]
    public int ProductId { get; set; }

    [Required]
    public string Name { get; set; }

    public decimal Price { get; set; }
}

This class defines a Product entity with a primary key, a required Name, and a Price.

DbContext Setup

using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=ProductDb;Trusted_Connection=True;");
    }
}

This DbContext configures a SQL Server connection and includes a DbSet for Products.

Applying a Migration

Add-Migration InitialCreate
Update-Database

These commands create the initial migration and update the database schema accordingly.

Best Practices

Keep your entity classes simple and focused on the domain.
Use migrations to manage database schema changes instead of manual scripts.
Leverage Fluent API for complex configurations instead of data annotations.
Regularly update your database after model changes to avoid drift.

Common Mistakes

Not defining a primary key in entity classes.
Ignoring migrations and manually changing the database schema.
Mixing database-first and code-first approaches in the same project.
Hardcoding connection strings instead of using configuration files.

Hands-on Exercise

Create a Customer Entity

Define a Customer class with properties Id, FirstName, LastName, and Email. Add it to a DbContext and create a migration.

Expected output: A migration that creates a Customers table with the specified columns.

Hint: Use [Key] for Id and [Required] for necessary fields.

Configure One-to-Many Relationship

Add an Order entity related to Customer. Configure a one-to-many relationship where one Customer can have many Orders.

Expected output: A migration that creates Orders table with a foreign key to Customers.

Hint: Use navigation properties and Fluent API or data annotations.

Interview Questions

What is the Code First approach in Entity Framework Core?

Interview

Code First is a development approach where you define your database schema using C# classes, and EF Core generates the database based on these classes.

How do you apply database schema changes in Code First?

Interview

You create migrations using EF Core tools and then apply them to the database with commands like 'Add-Migration' and 'Update-Database'.

What is the role of DbContext in EF Core?

Interview

DbContext manages entity objects during runtime, handles database connections, and provides APIs for querying and saving data.