Ako implementovať vzťah mnoho na mnoho v C#?

Vzťah "mnoho k mnohým" v C# s použitím Entity Framework Core sa zvyčajne realizuje prostredníctvom prechodnej (spájacej) tabuľky.

Kroky implementácie:

1. Vytvorenie entít: Definujte dve triedy entít pre obe strany vzťahu.
2. Vytvorenie prechodnej entity: Vytvorte samostatnú triedu entity pre prechodnú tabuľku. Táto entita bude obsahovať cudzie kľúče na obe prepojené entity a, voliteľne, ďalšie vlastnosti opisujúce samotný vzťah.
3. Nastavenie vzťahov v DbContext: V metóde OnModelCreating vášho DbContext nastavte vzťahy medzi prechodnou entitou a dvoma hlavnými entitami. Použite metódy HasMany, WithMany, UsingEntity na explicitné nastavenie prechodnej tabuľky.

Príklad:

Predpokladajme, že máte entity Book a Author, a jedna kniha môže byť napísaná viacerými autormi, a jeden autor môže napísať viac kníh.

// Entita 1
public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public ICollection<BookAuthor> BookAuthors { get; set; }
}

// Entita 2
public class Author
{
    public int Id { get; set; }
    public string Name { get; set; }
    public ICollection<BookAuthor> BookAuthors { get; set; }
}

// Prechodná entita
public class BookAuthor
{
    public int BookId { get; set; }
    public Book Book { get; set; }

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

    // Dodatočné vlastnosti, napr. rola autora
    public string Role { get; set; }
}

// Nastavenie v 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 }); // Zložený primárny kľúč

        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);
    }
}

Použitie:

// Pridanie knihy a autora
var book = new Book { Title = "Moja úžasná kniha" };
var author = new Author { Name = "Jane Doe" };

var bookAuthor = new BookAuthor {
    Book = book,
    Author = author,
    Role = "Hlavný autor"
};

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

_context.SaveChanges();

// Získanie knihy s autormi
var bookWithAuthors = _context.Books
    .Include(b => b.BookAuthors)
    .ThenInclude(ba => ba.Author)
    .FirstOrDefault(b => b.Id == book.Id);

// Získanie autora s knihami
var authorWithBooks = _context.Authors
    .Include(a => a.BookAuthors)
    .ThenInclude(ba => ba.Book)
    .FirstOrDefault(a => a.Id == author.Id);

Tento prístup s prechodnou entitou je odporúčaný v EF Core, pretože umožňuje flexibilne spravovať dodatočné údaje o samotnej väzbe. V jednoduchších prípadoch EF Core môže automaticky vytvoriť skrytú prechodnú tabuľu, ale explicitné definovanie entity poskytuje väčšiu kontrolu.