Code First Approach

C# Entity Framework's Code First approach is a fantastic technique that allows developers to build their databases based on their code. Instead of writing SQL code to create a database and its tables, you write C# classes. The Entity Framework then translates these classes into SQL and creates the database for you. This approach is especially useful for developers who prefer to work in code rather than dealing with the database directly.

What is Code First Approach?

Code First is one of three methods in Entity Framework that you can use to build your database. The other two are Database First and Model First. Code First is a popular choice because it enables you to work in a domain-oriented design pattern. This means you can focus on the business requirements and let the Entity Framework handle the database.

Setting Up a Code First Project

To get started with Code First, you'll first need to install the Entity Framework NuGet package. Open your Package Manager Console and run the following command:

Install-Package EntityFramework

After installation, you can start creating your database context and entity classes. The database context is a bridge between your entities (classes) and the database. It allows you to query and save data.

Here's a simple example of a database context:

public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
}

In this example, BloggingContext is your database context, and Blog and Post are your entities. Each DbSet represents a table in your database.

Creating Entities

Entities in Code First are simply your domain classes. They don't need to inherit from any special base class or interface. Here's an example of what the Blog and Post classes might look like:

public class Blog
{
    public int BlogId { get; set; }
    public string Name { get; set; }
    public virtual List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public int BlogId { get; set; }
    public virtual Blog Blog { get; set; }
}

In these classes, each property represents a column in the table. The virtual keyword allows Entity Framework to use lazy loading, which means that related entities are only loaded when you access them.

Creating the Database

Once you have your context and entities set up, you can create your database. Simply create a new instance of your context and call a method on it. Here's an example:

using (var db = new BloggingContext())
{
    db.Blogs.Add(new Blog { Name = "My Blog" });
    db.SaveChanges();
}

In this code, a new Blog is added to the Blogs table and saved to the database. If the database doesn't exist, Entity Framework will create it for you.

Code First Migrations

When you make changes to your entities, you'll need to update your database to reflect these changes. Entity Framework provides a feature called Migrations to handle this. Migrations allow you to keep your database in sync with your code by preserving data.

To enable migrations, open your Package Manager Console and run the following command:

Enable-Migrations

When you make changes to your entities, you can add a new migration with the following command:

Add-Migration "DescriptiveName"

And to update your database with the migration, you run:

Update-Database

The Code First approach in Entity Framework is a powerful tool that allows you to build your database based on your code. It's a great option for developers who prefer to work in a domain-oriented design pattern and let the framework handle the database.