LuisLlamas Logo
entity-framework-relaciones-uno-a-muchos

One to Many Relationships in Entity Framework

  • 4 min
  • Beginner

A one-to-many (1) relationship occurs when an entity A can have many instances of an entity B, but each instance of B is related to only one A.

In other words, a record in one table can be related to several records in another table, but a record in the second table can only be associated with one record in the first table.

This is the most common type of relationship in databases.

Let’s model a system where:

  • One Blog can have many Posts.
  • Each Post belongs to only one Blog.
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
    
    // Navigation property (1 → N)
    public ICollection<Post> Posts { get; set; } = new List<Post>();
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    
    // Implicit foreign key (BlogId)
    public int BlogId { get; set; }
    
    // Navigation property (N → 1)
    public Blog Blog { get; set; }
}
Copied!

Configure the Relationship

Using Naming Conventions

Entity Framework automatically infers the 1relationship if:

  • The “one” entity (Blog) has a collection of the “many” entity (ICollection<Post>).
  • The “many” entity (Post) has:
    • A navigation property pointing to the “one” (public Blog Blog).
    • A foreign key that follows the {ClassName}Id convention (BlogId).

Using Data Annotations

If we don’t follow the conventions, we can use attributes:

[ForeignKey] on the foreign key

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

    [ForeignKey("Blog")] // Indicates that BlogId is FK of Blog
    public int BlogForeignKey { get; set; } // Non-conventional name

    public Blog Blog { get; set; }
}
Copied!

[InverseProperty] for ambiguous relationships. Useful when there are multiple relationships between the same entities.

public class Blog
{
    public int BlogId { get; set; }
    
    [InverseProperty("Blog")] // Clarifies which property in Post corresponds
    public ICollection<Post> Posts { get; set; }
}
Copied!

Using Fluent API

In the DbContext, we use OnModelCreating:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(b => b.Posts)       // A Blog has many Posts
        .WithOne(p => p.Blog)        // A Post belongs to a Blog
        .HasForeignKey(p => p.BlogId); // Foreign key in Post
}
Copied!

Generated Database Structure

When applying a migration, EF creates the tables:

CREATE TABLE Blogs (
    BlogId INT PRIMARY KEY IDENTITY,
    Url NVARCHAR(MAX)
);

CREATE TABLE Posts (
    PostId INT PRIMARY KEY IDENTITY,
    Title NVARCHAR(MAX),
    Content NVARCHAR(MAX),
    BlogId INT NOT NULL,
    FOREIGN KEY (BlogId) REFERENCES Blogs(BlogId)
);
Copied!

BlogId in Posts is a non-unique foreign key (allows multiple posts per blog).

Advanced Configurations

Besides basic relationships, Entity Framework allows advanced configuration of aspects of the relationships between entities. This includes:

Relationship with Cascade Delete

When a related entity is deleted, cascade delete ensures that all related entities are also deleted.

modelBuilder.Entity<Book>()
    .HasOne(l => l.Author)
    .WithMany(a => a.Books)
    .OnDelete(DeleteBehavior.Cascade);
Copied!

Read-Only Relationship

In some situations, you may not want to allow a relationship to be modified in an entity.

modelBuilder.Entity<Book>()
    .HasOne(l => l.Author)
    .WithMany(a => a.Books)
    .OnDelete(DeleteBehavior.Restrict);
Copied!

Optional Relationships

Some relationships are optional, meaning an entity may not have a relationship with the other.

modelBuilder.Entity<Book>()
    .HasOne(l => l.Author)
    .WithMany(a => a.Books)
    .IsRequired(false);  // Optional relationship
Copied!

Practical Examples

Explicit Loading

using (var context = new AppDbContext())
{
    var blog = context.Blogs.Find(1); // Query 1: Retrieve Blog
    var posts = context.Posts.Where(p => p.BlogId == blog.BlogId).ToList(); // Query 2: Retrieve Posts
}
Copied!

Eager Loading

var blogWithPosts = context.Blogs
    .Include(b => b.Posts) // Automatic JOIN
    .FirstOrDefault(b => b.BlogId == 1);
Copied!

Lazy Loading

Requires navigation properties to be virtual.

public class Blog
{
    public virtual ICollection<Post> Posts { get; set; }
}

// When accessing blog.Posts, EF automatically loads the posts
var blog = context.Blogs.Find(1);
var posts = blog.Posts; // Load on demand
Copied!

Insert Blog with Posts

using (var context = new AppDbContext())
{
    var blog = new Blog { Url = "https://example.com" };
    blog.Posts.Add(new Post { Title = "First Post", Content = "Content..." });
    blog.Posts.Add(new Post { Title = "Second Post", Content = "More content..." });

    context.Blogs.Add(blog);
    context.SaveChanges(); // Saves Blog and Posts in one transaction
}
Copied!

Insert Post into an Existing Blog

var blog = context.Blogs.Find(1);
var newPost = new Post { Title = "New Post", BlogId = blog.BlogId };

context.Posts.Add(newPost);
context.SaveChanges();
Copied!

On this page