How do you create a model class in EF Core?

In Entity Framework Core (EF Core), creating a model class involves defining a C# class that represents a table in the database. Each property in the class maps to a column in the database table, and each instance of the class represents a row in that table.

Here’s how to create a model class in EF Core:

1. Define the Model Class

A model class should represent the data you want to store in the database. Typically, it includes properties that map to database columns, with a property designated as the primary key (usually Id or a similar identifier). Each property’s data type corresponds to the database column’s data type.

Example of a basic model class for an Employee entity:

public class Employee
{
    // Primary key property
    public int Id { get; set; }

    // Other properties
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }

    // Example of additional fields
    public DateTime DateOfBirth { get; set; }
    public decimal Salary { get; set; }
}

2. Configure the Model (Optional)

EF Core will automatically map properties in your model class to database columns with conventions. However, you can override the defaults with data annotations or the Fluent API (in the OnModelCreating method) to specify additional configurations.

Using Data Annotations

Data annotations are attributes you apply directly on model properties to configure aspects like primary keys, column constraints, required fields, etc.

public class Employee
{
    public int Id { get; set; }

    [Required] // Marks the column as NOT NULL
    [MaxLength(50)] // Limits string length in the database
    public string FirstName { get; set; }

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

    [Required]
    [EmailAddress] // Specifies a valid email format
    public string Email { get; set; }

    public DateTime DateOfBirth { get; set; }

    [Range(0, 100000)] // Limits salary range
    public decimal Salary { get; set; }
}

Using Fluent API

If you want more control, use the Fluent API in OnModelCreating in your DbContext. This is where you can configure relationships, table names, indices, and constraints in more detail.

public class AppDbContext : DbContext
{
    public DbSet<Employee> Employees { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Employee>()
            .Property(e => e.FirstName)
            .HasMaxLength(50)
            .IsRequired();

        modelBuilder.Entity<Employee>()
            .Property(e => e.LastName)
            .HasMaxLength(50)
            .IsRequired();

        modelBuilder.Entity<Employee>()
            .Property(e => e.Email)
            .IsRequired();

        modelBuilder.Entity<Employee>()
            .Property(e => e.Salary)
            .HasDefaultValue(0);
    }
}

3. Add the Model to the DbContext

In EF Core, you need a DbContext class that contains DbSet properties representing the tables in the database. Add a DbSet<Employee> to the DbContext to indicate that Employee is a model you want to include.

public class AppDbContext : DbContext
{
    public DbSet<Employee> Employees { get; set; }

    public AppDbContext(DbContextOptions<AppDbContext> options)
        : base(options) { }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Use Fluent API configurations (if any)
    }
}

4. Create and Apply Migrations

Once your model and DbContext are defined, you can create and apply migrations to create the corresponding tables in your database.

1. Add Migration:

   
   dotnet ef migrations add InitialCreate
   

2. Update Database:

   
   dotnet ef database update
   

This will generate the necessary SQL commands to create the Employees table with the defined schema.

Summary

Creating a model class in EF Core involves:

• Defining a C# class that represents the database table.
• Adding properties to represent columns.
• Optionally, using data annotations or the Fluent API to fine-tune the configuration.
• Adding the model to a DbContext class to include it in EF Core’s context.

This setup provides a straightforward way to map C# classes to relational database tables, and EF Core will handle the interaction between the application and the database.