Hogyan valósítható meg a több-több kapcsolat C#-ban…

A "sok-sok" kapcsolat C#-ban az Entity Framework Core használatával általában egy közbenső (kapcsolódó) táblán keresztül valósul meg.

Megvalósítás lépései:

Entitások létrehozása: Határozzon meg két entitásosztályt a kapcsolat mindkét oldalához.
Közbenső entitás létrehozása: Hozzon létre egy külön entitásosztályt a közbenső táblához. Ez az entitás tartalmazza mindkét kapcsolódó entitás külső kulcsait, és opcionálisan további tulajdonságokat, amelyek a kapcsolatot írják le.
Kapcsolatok beállítása a DbContext-ben: A OnModelCreating módszerben a DbContext-ben állítsa be a kapcsolatokat a közbenső entitás és a két fő entitás között. Használja a HasMany, WithMany, UsingEntity metódusokat.

Példa:

Tegyük fel, hogy van Book és Author entitás, és egy könyvet több szerző írhat, egy szerző pedig több könyvet.

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

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

// Közbenső entitás
public class BookAuthor
{
    public int BookId { get; set; }
    public Book Book { get; set; }

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

    // További tulajdonságok, pl. a szerző szerepe a könyvben
    public string Role { get; set; }
}

// Beállítás a DbContext-ben
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 }); // Összetett elsődleges kulcs

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

Használat:

// Könyv és szerző hozzáadása
var book = new Book { Title = "Az én Csodálatos Könyvem" };
var author = new Author { Name = "Jane Doe" };

var bookAuthor = new BookAuthor {
    Book = book,
    Author = author,
    Role = "Elsődleges Szerző"
};

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

_context.SaveChanges();

// Könyv szerzőkkel
var bookWithAuthors = _context.Books
    .Include(b => b.BookAuthors)
    .ThenInclude(ba => ba.Author)
    .FirstOrDefault(b => b.Id == book.Id);

// Szerző könyvekkel
var authorWithBooks = _context.Authors
    .Include(a => a.BookAuthors)
    .ThenInclude(ba => ba.Book)
    .FirstOrDefault(a => a.Id == author.Id);

Ez a megközelítés a közbenső entitással a legajánlott az EF Core-ban, mivel lehetővé teszi a kapcsolat további adatainak rugalmas kezelését. Egyszerűbb esetekben az EF Core automatikusan létrehozhat egy rejtett közbenső táblát, de a nyilvános entitás meghatározása nagyobb kontrollt biztosít.

Hogyan valósítható meg a több-több kapcsolat C#-ban?