MSDN

Working with Relationships in EF Core

Entity Framework Core (EF Core) provides robust support for modeling and managing relationships between entities in your application. Understanding how to define and work with these relationships is crucial for building well-structured and efficient data access layers.

Types of Relationships

EF Core supports the following common relationship types:

• One-to-One: Each entity in one set is related to exactly one entity in another set, and vice-versa.
• One-to-Many: Each entity in one set can be related to multiple entities in another set, but each entity in the second set is related to only one entity in the first set.
• Many-to-Many: Each entity in one set can be related to multiple entities in another set, and vice-versa.

Defining Relationships

Relationships are typically defined using navigation properties in your entity classes. EF Core's conventions can often infer relationships, but you can also explicitly configure them using the Fluent API.

Example: One-to-Many Relationship (Blog and Posts)

Consider a scenario where a Blog can have many Posts, but each Post belongs to a single Blog.

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    // Navigation property to access all posts for this blog
    public List<Post> Posts { get; set; }
}

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

    // Foreign key property
    public int BlogId { get; set; }
    // Navigation property to access the blog this post belongs to
    public Blog Blog { get; set; }
}
                

In this example:

• The Blog class has a List<Post> navigation property, indicating a one-to-many relationship.
• The Post class has a foreign key property (BlogId) and a navigation property (Blog) back to the Blog.

Configuring Relationships with Fluent API

While conventions work well, you might need more control. The OnModelCreating method in your DbContext is where you can use the Fluent API.

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .HasMany(b => b.Posts) // Blog has many Posts
            .WithOne(p => p.Blog)  // Each Post belongs to one Blog
            .HasForeignKey(p => p.BlogId); // Specify the foreign key property
    }
}
                

Querying Related Data

EF Core makes it easy to load related data. You can use:

• Eager Loading: Load related data along with the main entity using Include() or ThenInclude().
• Lazy Loading: (Requires configuration and virtual navigation properties) Load related data only when you access the navigation property.
• Explicit Loading: Load related data for an entity after it has already been retrieved from the database.

Example: Eager Loading Posts for a Blog

// Get a blog and eagerly load its posts
var blogWithPosts = dbContext.Blogs
    .Include(b => b.Posts)
    .FirstOrDefault(b => b.BlogId == 1);

if (blogWithPosts != null)
{
    Console.WriteLine($"Blog: {blogWithPosts.Url}");
    foreach (var post in blogWithPosts.Posts)
    {
        Console.WriteLine($"- {post.Title}");
    }
}
                

Managing Relationships

When you add, remove, or update entities involved in a relationship, EF Core tracks these changes and generates the appropriate SQL for your database.

Example: Adding a New Post to a Blog

var existingBlog = dbContext.Blogs.Find(1);
if (existingBlog != null)
{
    var newPost = new Post
    {
        Title = "My New Post",
        Content = "This is the content.",
        Blog = existingBlog // EF Core will set the BlogId automatically
    };
    dbContext.Posts.Add(newPost);
    await dbContext.SaveChangesAsync();
}
                

Many-to-Many Relationships

Many-to-many relationships require a third "join" or "linking" table. EF Core can automatically create this table for you.

Example: Students and Courses

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public List<Course> Courses { get; set; }
}

public class Course
{
    public int CourseId { get; set; }
    public string Title { get; set; }
    public List<Student> Students { get; set; }
}

// In DbContext.OnModelCreating:
modelBuilder.Entity<Student>()
    .HasMany(s => s.Courses)
    .WithMany(c => c.Students)
    .UsingEntity<StudentCourse>( // Optional: specify the join entity
        j => j.HasOne(sc => sc.Course).WithMany().HasForeignKey(sc => sc.CourseId),
        j => j.HasOne(sc => sc.Student).WithMany().HasForeignKey(sc => sc.StudentId)
    );
                

EF Core will create a StudentCourse table with StudentId and CourseId columns to manage this many-to-many relationship.