Связь "многие ко многим" в C# с использованием Entity Framework Core обычно реализуется через промежуточную (соединительную) таблицу.

Шаги реализации:

Создание сущностей: Определите два класса сущностей для обеих сторон связи.
Создание промежуточной сущности: Создайте отдельный класс сущности для промежуточной таблицы. Эта сущность будет содержать внешние ключи на обе связанные сущности и, опционально, дополнительные свойства, описывающие саму связь.
Настройка отношений в DbContext: В методе OnModelCreating вашего DbContext настройте отношения между промежуточной сущностью и двумя основными сущностями. Используйте методы HasMany, WithMany, UsingEntity для явной настройки промежуточной таблицы.

Пример:

Предположим, у вас есть сущности Book и Author, и одна книга может быть написана несколькими авторами, а один автор может написать несколько книг.

// Сущность 1
public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public ICollection<BookAuthor> BookAuthors { get; set; }
}

// Сущность 2
public class Author
{
    public int Id { get; set; }
    public string Name { get; set; }
    public ICollection<BookAuthor> BookAuthors { get; set; }
}

// Промежуточная сущность
public class BookAuthor
{
    public int BookId { get; set; }
    public Book Book { get; set; }

    public int AuthorId { get; set; }
    public Author Author { get; set; }

    // Дополнительные свойства, например, роль автора в книге
    public string Role { get; set; }
}

// Настройка в DbContext
public class ApplicationDbContext : DbContext
{
    public DbSet<Book> Books { get; set; }
    public DbSet<Author> Authors { get; set; }
    public DbSet<BookAuthor> BookAuthors { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<BookAuthor>()
            .HasKey(ba => new { ba.BookId, ba.AuthorId }); // Составной первичный ключ

        modelBuilder.Entity<BookAuthor>()
            .HasOne(ba => ba.Book)
            .WithMany(b => b.BookAuthors)
            .HasForeignKey(ba => ba.BookId);

        modelBuilder.Entity<BookAuthor>()
            .HasOne(ba => ba.Author)
            .WithMany(a => a.BookAuthors)
            .HasForeignKey(ba => ba.AuthorId);
    }
}

Использование:

// Добавление книги и автора
var book = new Book { Title = "My Awesome Book" };
var author = new Author { Name = "Jane Doe" };

var bookAuthor = new BookAuthor {
    Book = book,
    Author = author,
    Role = "Primary Author"
};

_context.Books.Add(book);
_context.Authors.Add(author);
_context.BookAuthors.Add(bookAuthor);

_context.SaveChanges();

// Получение книги с авторами
var bookWithAuthors = _context.Books
    .Include(b => b.BookAuthors)
    .ThenInclude(ba => ba.Author)
    .FirstOrDefault(b => b.Id == book.Id);

// Получение автора с книгами
var authorWithBooks = _context.Authors
    .Include(a => a.BookAuthors)
    .ThenInclude(ba => ba.Book)
    .FirstOrDefault(a => a.Id == author.Id);

Этот подход с промежуточной сущностью является рекомендуемым в EF Core, так как позволяет гибко управлять дополнительными данными о самой связи. В более простых случаях EF Core может самостоятельно создать скрытую промежуточную таблицу, но явное определение сущности дает больший контроль.

Как реализовать связь многие ко многим в C#?