How to insert record into Join table in EF Core

Question

I'm new to Entity Framework Core code first (using EF Core 6.07). I am attempting to insert a record into a join table with two columns, but I am getting an error of "InvalidOperationException: The value of 'MovieGenre.MovieId' is unknown when attempting to save changes. This is because the property is also part of a foreign key for which the principal entity in the relationship is not known." The join table is as follows:

    public class MovieGenre
    {
        [Required(ErrorMessage = "Movie Id required")]
        public int MovieId { get; set; }
        public Movies Movies { get; set; }

        [Required(ErrorMessage = "Genre Id required")]
        public int GenreId { get; set; }
        public Genre Genre { get; set; }
    }

Its two columns reference the ID columns of the following tables:

    public class Movies
    {
        [Key]
        public int MovieId { get; set; }

        [Required(ErrorMessage = "Title cannot be Null")]
        [Column(TypeName = "nvarchar(256)")]
        public string Title { get; set; }

        [Column(TypeName = "nvarchar(MAX)")]
        public string Overview { get; set; }

        [Column(TypeName = "nvarchar(512)")]
        public string Tagline { get; set; }

        [Column(TypeName = "decimal(18,2)")]
        public decimal Budget { get; set; }

        [Column(TypeName = "decimal(18,2)")]
        public decimal Revenue { get; set; }

        [Column(TypeName = "nvarchar(2084)")]
        public string ImdbUrl { get; set; }

        [Column(TypeName = "nvarchar(2084)")]
        public string TmdbUrl { get; set; }

        [Column(TypeName = "nvarchar(2084)")]
        public string PosterUrl { get; set; }

        [Column(TypeName = "nvarchar(2084)")]
        public string BackdropUrl { get; set; }

        [Column(TypeName = "nvarchar(64)")]
        public string OriginalLanguage { get; set; }

        [Column(TypeName = "datetime2(7)")]

        public DateTime ReleaseDate { get; set; }

        public int RunTime { get; set; }

        [Column(TypeName = "decimal(5,2)")]
        public decimal Price { get; set; }

        [Column(TypeName = "datetime2(7)")]
        public DateTime CreatedDate { get; set; }

        [Column(TypeName = "datetime2(7)")]
        public DateTime UpdatedDate { get; set; }

        [Column(TypeName = "nvarchar(MAX)")]
        public string UpdatedBy { get; set; }

        [Column(TypeName = "nvarchar(MAX)")]
        public string CreatedBy { get; set; }
        
        public List<MovieCrew> MovieCrews { get; set; }

        public List<MovieCast> MovieCasts { get; set; }

        public List<MovieGenre> MovieGenres { get; set; }

        public List<Trailer> Trailers { get; set; }

        public List<Favorite> Favorites { get; set; }

        public List<Purchase> Purchases { get; set; }

        public List<Review> Reviews { get; set; }
    }

    public class Genre
    {
        [Key]
        public int GenreId { get; set; }

        [Required(ErrorMessage = "Name cannot be null")]
        [Column(TypeName = "nvarchar(64)")]
        public string Name { get; set; }

        public List<MovieGenre> MovieGenres { get; set; }
    }

I have also set up my custom DB context file to manually specify the foreign key relationships between the two primary tables and the join table. Also, I have added the two foreign key columns in the join table as a composite primary key.

protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Movies>()
                .HasMany(x => x.MovieGenres).WithOne(x => x.Movies).HasForeignKey(x => x.MovieId);
            modelBuilder.Entity<Genre>()
                .HasMany(x => x.MovieGenres).WithOne(x => x.Genre).HasForeignKey(x => x.GenreId);

            modelBuilder.Entity<MovieGenre>()
                .HasKey(o => new { o.MovieId, o.GenreId });
        }

I am attempting to insert data into the join table using a model, controller, and view. I am able to successfully insert into the Movies and Genre tables, but when I try to do so for the join table, MovieGenre, I am getting the error mentioned in bold above. The MovieID and GenreID I am attempting to insert into the join table already exist in the Movie and Genre tables. Can someone please help me learn what I am doing wrong?

Edit: Adding the code I am using to insert into the cross-reference table.

IRepositoryAsync:

using System;
namespace Antra.Movie.Core.Contracts.Repositories
{
    public interface IRepositoryAsync<T> where T: class
    {
        Task<int> InsertAsync(T Entity);
        Task<int> UpdateAsync(T Entity);
        Task<T> GetByIdAsync(int id);
        Task<int> DeleteAsync(int id);
        Task<IEnumerable<T>> GetAllAsync();
    }
}

IMovieGenreRepositoryAsync:

using System;
using Antra.Movie.Core.Entities;
namespace Antra.Movie.Core.Contracts.Repositories
{
    public interface IMovieGenreRepositoryAsync:IRepositoryAsync<MovieGenre>
    {
    }
}

BaseRepositoryAsync:

using System;
using Antra.Movie.Core.Contracts.Repositories;
using Antra.Movie.Infrastructure.Data;
using Microsoft.EntityFrameworkCore;

namespace Antra.Movie.Infrastructure.Repositories
{
    public class BaseRepositoryAsync<T>:IRepositoryAsync<T> where T: class
    {

        MovieDbContext db;

        public BaseRepositoryAsync(MovieDbContext _context)
        {
            db = _context;
        }

        public async Task<int> DeleteAsync(int id)
        {
            var entity = await db.Set<T>().FindAsync(id);
            db.Set<T>().Remove(entity);
            return await db.SaveChangesAsync();

        }

        public async Task<IEnumerable<T>> GetAllAsync()
        {
            return await db.Set<T>().ToListAsync();
        }

        public async Task<T> GetByIdAsync(int id)
        {
            var entity = await db.Set<T>().FindAsync(id);
            return entity;
        }

        public async Task<int> InsertAsync(T Entity)
        {
            await db.Set<T>().AddAsync(Entity);
            return await db.SaveChangesAsync();

        }

        public async Task<int> UpdateAsync(T Entity)
        {
            db.Entry<T>(Entity).State = EntityState.Modified;
            return await db.SaveChangesAsync();
        }
    }
}

MovieGenreRepositoryAsync:

using System;
using Antra.Movie.Core.Contracts.Repositories;
using Antra.Movie.Core.Entities;
using Antra.Movie.Infrastructure.Data;

namespace Antra.Movie.Infrastructure.Repositories
{
    public class MovieGenreRepositoryAsync : BaseRepositoryAsync<MovieGenre>, IMovieGenreRepositoryAsync
    {
        public MovieGenreRepositoryAsync(MovieDbContext _context):base(_context)
        {
        }
    }
}

IMovieGenreServiceAsync:

using System;
using Antra.Movie.Core.Model;

namespace Antra.Movie.Infrastructure.Services
{
    public interface IMovieGenreServiceAsync
    {
        Task<int> InsertMovieGenre(MovieGenreModel _movieGenreModel);
    }
}

MovieGenreServiceAsync:

using System;
using Antra.Movie.Core.Contracts.Repositories;
using Antra.Movie.Core.Entities;
using Antra.Movie.Core.Model;

namespace Antra.Movie.Infrastructure.Services
{
    public class MovieGenreServiceAsync:IMovieGenreServiceAsync
    {
        IMovieGenreRepositoryAsync MovieGenreRepo;
        public MovieGenreServiceAsync(IMovieGenreRepositoryAsync _movieGenreRepo)
        {
            MovieGenreRepo = _movieGenreRepo;
        }

        public async Task<int> InsertMovieGenre(MovieGenreModel _movieGenreModel)
        {
            MovieGenre moviegenreentity = new MovieGenre()
            {
                MovieId = _movieGenreModel.MovieId,
                GenreId = _movieGenreModel.GenreId
            };
            return await MovieGenreRepo.InsertAsync(moviegenreentity);
        }
    }
}

MovieGenreModel:

using System;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Antra.Movie.Core.Entities;

namespace Antra.Movie.Core.Model
{
    public class MovieGenreModel
    {
        [Required(ErrorMessage = "Movie Id required")]
        public int MovieId { get; set; }
        public Movies Movies { get; set; }

        [Required(ErrorMessage = "Genre Id required")]
        public int GenreId { get; set; }
        public Genre Genre { get; set; }

        public MovieGenreModel()
        {
        }
    }
}

MovieGenreController:

using System;
using Antra.Movie.Core.Model;
using Antra.Movie.Infrastructure.Services;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;

namespace Antra.Movie.WebMVC.Controllers
{
    public class MovieGenreController:Controller
    {
        IGenreServiceAsync genreServiceAsync;
        IMovieServiceAsync movieServiceAsync;
        IMovieGenreServiceAsync movieGenreServiceAsync;
        public MovieGenreController(IGenreServiceAsync _genreService, IMovieServiceAsync _movieService, IMovieGenreServiceAsync _moviegenreService)
        {
            genreServiceAsync = _genreService;
            movieServiceAsync = _movieService;
            movieGenreServiceAsync = _moviegenreService;
        }
        public async Task<IActionResult> Index()
        {
            ViewBag.GenreSelect = new SelectList(await genreServiceAsync.GetAllGenres(), "Id", "Name");

            return View();
        }
        [HttpGet]
        public IActionResult Create()
        {
            return View();
        }
        [HttpPost]
        public async Task<IActionResult> Create(MovieGenreModel _model)
        {
            if (ModelState.IsValid)
            {
                await movieGenreServiceAsync.InsertMovieGenre(_model);
            }
            return View(_model);
        }
    }
}

Create.cshtml view for the MovieGenreController:

@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@model GenreModel
<form method="post" asp-controller="MovieGenre" asp-action="Create">
    <div class="form-group">
        <label for="GenreName">GenreId</label>
        <input type="text" name="Name" class="form-control" id="GenreName" placeholder="Enter genre name">
        <span asp-validation-for="Name"></span>
    </div>
    <div class="form-group">
        <label for="GenreName">MovieId</label>
        <input type="text" name="Name" class="form-control" id="GenreName" placeholder="Enter genre name">
        <span asp-validation-for="Name"></span>
    </div>
    <button type="submit" class="btn btn-primary">Save</button>
</form>

Answer 1

First of all You don't need mapping table as MovieGenre unless you don't have any specific properties in it. Also you don't need to do anything in the DbContext if you use code first, the mapping and everything you need will be created automatically except the DbSets . So I would recommend:

In the context

public virtual DbSet<Movie> Movies { get; set; }
public virtual DbSet<Genre> Genres { get; set; }

Movies

public class Movie
{
   public Movie()
   {
       this.Genres = new HashSet<Genre>();
   }

    public int Id { get; set; }

    // Other Props....

    public virtual ICollection<Genre> Genres { get; set; }
}

Genres

public class Genre
{
    public Genre()
    {
        this.Movies = new HashSet<Movie>();
    }

    public int Id { get; set; }

    //Other Props....

    public virtual ICollection<Movie> Movies { get; set; }
}

No need to add separates,

var genre = new Genre { Name = "Action" };
var movie = new Movie { Name = "MovieName" };
movie.Genres.Add(genre);

await context.AddAsync(movie);
await context.SaveChangesAsync();

Query

//by movie name
var moviesByName = db.Movies.Include(x => x.Genres).Where(x => x.Name = "MovieName").ToList();
//by genre
var moviesByGenres = context.Movies.Include(x => x.Genres).Where(x => x.Genres.Any(x => x.Name == "Action")).ToList();