Marc Fabregat - Entity Framwork core 5 - Many to Many relationships

August 8, 2021

Entity Framwork core 5 - Many to Many relationships

Entity Framework core

Lately, I've been working on a project using Entity Framework core 5. I read the release notes and I realized that finally there is a good solution to implement Many-to-Many DB relationships on Entity Framework.

In previous EF versions, when we had two entities with Many to Many relationships(M2M from now on), we had to add a third entity on our context to represent the join table. Also, we had to add the relationships of this join table on each table, ending up configuring the relationship using fluent API. All this process was quite cumbersome.

With the EF core 5 version, there is no need to create the join table, nor use the fluent API(at least on basic examples), Entity Framework figures it out for us and generate the join table on the DB schema directly.

In this tutorial, we will create a basic example with a M2M relationship.

Let's create a typical example. We have two entities, `Teacher` and `Student`. A `Teacher` can have multiple `Students`, and each `Student` has multiple `Teachers`. Using Entity Framework, we want to retrieve `Teachers` with their `Students`, also we want to retrieve the list of `Teachers` from a certain `Student`.

You can download the repository in case you want to run the solution along with this tutorial:
[https://github.com/marcfabregatb/EFCore5ManyToManyRelationships](https://github.com/marcfabregatb/EFCore5ManyToManyRelationships)

## Create Project
This tutorial is based on Asp Mvc Core 5 application. Although it can be applied to any other project with Entity Framework core 5.
![create mvc core 5 project](\img\Uploads\0f03aa62-27eb-483e-b319-8d10fe0c8502_1628628046669.png 'create mvc core 5 project')

## Nuget packages
we will only need two nuget packages:

- Microsoft.EntityFrameworkCore.Tools
- Microsoft.EntityFrameworkCore.SqlServer

## Models

#####Student.cs
```csharp
   public class Student
   {
      [Key]
      public int Id { get; set; }
      [Required]
      public string Name { get; set; }

//Student has many teachers
      public ICollection<Teacher> Teachers { get; set; }
   }
```

#####Teacher.cs
```csharp
   public class Teacher
   {
      [Key]
      public int Id { get; set; }
      [Required]
      public string Name { get; set; }

//teacher has many students
      public ICollection<Student> Students { get; set; }
   }
```

Here we have the two entities, `Teacher` and `Student`, each one with an ICollection of the other entity.

## setup dbContext
DbContext with seeding
##### DefaultDbContext.cs
```csharp
public class DefaultDbContext : DbContext
   {
      public DefaultDbContext(DbContextOptions options) : base(options)
      {

}

public DbSet<Teacher> Teachers { get; set; }
      public DbSet<Student> Students { get; set; }

//seed data
      protected override void OnModelCreating(ModelBuilder modelBuilder)
      {
         base.OnModelCreating(modelBuilder);

modelBuilder.Entity<Teacher>().HasData(
            new Teacher() { Id = 1, Name = " teacher 1" },
            new Teacher() { Id = 2, Name = " teacher 2" },
            new Teacher() { Id = 3, Name = " teacher 3" }
         );

modelBuilder.Entity<Student>().HasData(
            new Student() { Id = 1, Name = "Student 1" },
            new Student() { Id = 2, Name = "Student 2" },
            new Student() { Id = 3, Name = "Student 3" },
            new Student() { Id = 4, Name = "Student 4" }
         );

modelBuilder
            .Entity<Teacher>()
            .HasMany(p => p.Students)
            .WithMany(p => p.Teachers)
            .UsingEntity(j => j.HasData(
               new { TeachersId = 1, StudentsId = 1 },
               new { TeachersId = 1, StudentsId = 2 },
               new { TeachersId = 1, StudentsId = 3 },
               new { TeachersId = 1, StudentsId = 4 },
               new { TeachersId = 2, StudentsId = 2 },
               new { TeachersId = 2, StudentsId = 3 },
               new { TeachersId = 3, StudentsId = 1 },
               new { TeachersId = 3, StudentsId = 4 }
            ));
      }
   }
```

#####appsettings.json
configure connection string
```json
   "ConnectionStrings": {
      "DefaultConnectionString": "Server=(localdb)\\mssqllocaldb;Database=EFCore5ManyToManyExample;Trusted_Connection=True;MultipleActiveResultSets=true"
   }
```
#####Startup.cs
```csharp
      public void ConfigureServices(IServiceCollection services)
      {
         services.AddControllersWithViews();
         
         //inject DbContext
         services.AddDbContext<DefaultDbContext>(options =>
         {
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnectionString"));
         });
      }
```

#####Initialize Database
in order to create and seed the local database run these two commands on `Package Manager Console` 
```bash
add-migration Initialize
update-database
```

## Query Many To Many Relationships

All right. At this point, we are good to query the entities.
#####TeachersController.cs
```csharp
        public async Task<IActionResult> Index()
        {
            var teachers = await _context.Teachers.Include(t => t.Students).ToListAsync();
            return View(teachers);
        }
```

To retrieve the values from the M2M relationships we just need to include the foreign table, in this case, Categories and Entity Framework will query the join table and return the values. As simple as is.

##Represent Join Table into DbContext

Of course, there are cases when we want to keep representing the join table. Sometimes we need to store more information on the relationship. For example, the date a student `Student` was assigned to a teacher.

In this case, we can always add the join table on the context. As we did on previous EF versions.

# GitHub repository
I published the repository on github if you want to run the full example. 
[https://github.com/marcfabregatb/EFCore5ManyToManyRelationships](https://github.com/marcfabregatb/EFCore5ManyToManyRelationships)

thanks for reading!

1 Comments

Adam

Appreciate the overview. It would have been interesting to see the full CRUD examples in the controller code.

Leave a comment

Filter by categories

Latests posts

Entity Framwork core 5 - Many to Many relationships

Lately, I've been working on a project using Entity Framework core 5. I read the...
Alguns dels meus llibres de desenvolupament de software preferits

Molts cops estàs parlant amb algú sobre enginyeria de software i acaba sortint a...

Entity Framwork core 5 - Many to Many relationships

Entity Framwork core 5 - Many to Many relationships

Alguns dels meus llibres de desenvolupament de software preferits