Fluent API, banyak-ke-banyak di Entity Framework Core

Saya telah mencari stackoverflow untuk solusi yang tepat dalam menghasilkan hubungan banyak ke banyak , menggunakan EF Core, Code first dan Fluent API.

Skenario sederhana adalah:

public class Person
{
    public Person() {
        Clubs = new HashSet<Club>();
    }
    public int PersonId { get; set; }
    public virtual ICollection<Club> Clubs { get; set; }
}

public class Club
{
    public Club() {
        Persons = new HashSet<Person>();
    }
    public int ClubId { get; set; }
    public virtual ICollection<Person> Persons { get; set; }
}

Harap perbaiki saya jika saya salah, tetapi sejujurnya saya tidak dapat menemukan pertanyaan yang berisi penjelasan terperinci tentang cara melakukan ini menggunakan alat yang dijelaskan. Adakah yang bisa menjelaskan bagaimana ini dilakukan?

EF Core 5.0 RC1 +

Pada EF Core 5.0 RC1, hal ini dapat dilakukan tanpa tabel gabungan eksplisit. EF Core dapat mengonfigurasi pemetaan untuk hubungan banyak-ke-banyak yang ditampilkan dalam pertanyaan Anda tanpa mengharuskan Anda membuat PersonClubtipe.

Lihat Yang Baru di EF Core 5.0, RC1, Many-to-many di dokumen resmi untuk informasi lebih lanjut.

Versi sebelumnya

Ini belum dapat dilakukan di EF Core tanpa menggunakan kelas eksplisit untuk bergabung. Lihat di sini untuk contoh bagaimana melakukan itu.

Ada masalah terbuka di Github yang meminta kemampuan untuk melakukan ini tanpa memerlukan kelas eksplisit, tetapi ini belum diselesaikan.

Menggunakan skenario Anda, contoh yang saya tautkan akan merekomendasikan kelas entitas berikut:

public class Person
{
    public int PersonId { get; set; }
    public virtual ICollection<PersonClub> PersonClubs { get; set; }
}

public class Club
{
    public int ClubId { get; set; }
    public virtual ICollection<PersonClub> PersonClubs { get; set; }
}

public class PersonClub
{
    public int PersonId { get; set; }
    public Person Person { get; set; }
    public int ClubId { get; set; }
    public Club Club { get; set; }
}

Berikut ini OnModelCreatingakan digunakan untuk penyiapan:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<PersonClub>()
        .HasKey(pc => new { pc.PersonId, pc.ClubId });

    modelBuilder.Entity<PersonClub>()
        .HasOne(pc => pc.Person)
        .WithMany(p => p.PersonClubs)
        .HasForeignKey(pc => pc.PersonId);

    modelBuilder.Entity<PersonClub>()
        .HasOne(pc => pc.Club)
        .WithMany(c => c.PersonClubs)
        .HasForeignKey(pc => pc.ClubId);
}

Pastikan untuk membuka masalah terbuka yang saya tautkan dan menyuarakan rasa frustrasi Anda jika Anda merasa perlu.

EDIT: Masalah terbuka menyarankan penggunaan yang sederhana Selectuntuk menavigasi melalui hierarki yang agak rumit ini. Untuk berpindah dari satu PersonIdke koleksi Club, Anda bisa menggunakan SelectMany. misalnya:

var clubs = dbContext.People
    .Where(p => p.PersonId == id)
    .SelectMany(p => p.PersonClubs);
    .Select(pc => pc.Club);

Saya tidak dapat menjamin apakah ini benar-benar sebuah "praktik terbaik", tetapi itu pasti berhasil dan saya pikir adil untuk mengatakan itu tidak terlalu jelek.

"Penyiapan" yang benar untuk ini adalah:

public class Person
{
    public int PersonId { get; set; }
    public virtual ICollection<PersonClub> PersonClubs { get; set; }
}

public class Club
{
    public int ClubId { get; set; }
    public virtual ICollection<PersonClub> PersonClubs { get; set; }
}

public class PersonClub
{
    public int PersonId { get; set; }
    public Person Person { get; set; }
    public int ClubId { get; set; }
    public Club Club { get; set; }
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<PersonClub>()
        .HasKey(pc => new { pc.PersonId, pc.ClubId });
}

Jadi, blok untuk mengkonfigurasi "glue-table" ini tidak diperlukan seperti pada contoh @Kirk:

modelBuilder.Entity<PersonClub>()
    .HasOne(pc => pc.Person)
    .WithMany(p => p.PersonClubs)
    .HasForeignKey(pc => pc.PersonId);

modelBuilder.Entity<PersonClub>()
    .HasOne(pc => pc.Club)
    .WithMany(c => c.PersonClubs)
    .HasForeignKey(pc => pc.ClubId);

Jadi setiap Personmemiliki nol atau lebih Clubsdan setiap Clubmemiliki nol atau lebih Persons. Seperti yang Anda nyatakan dengan benar, ini adalah relasi banyak-ke-banyak yang tepat.

Anda mungkin tahu bahwa database relasional memerlukan tabel tambahan untuk mengimplementasikan hubungan banyak-ke-banyak ini. Hal yang menyenangkan tentang kerangka entitas, adalah ia mengenali hubungan ini dan membuat tabel tambahan ini untuk Anda.

Pada pandangan pertama tampaknya masalah bahwa tabel tambahan ini tidak ada dbSetdi Anda DbContext: "Bagaimana cara melakukan penggabungan dengan tabel tambahan ini jika saya tidak memilikinya DbSet?".

Untungnya, Anda tidak perlu menyebutkan tabel tambahan ini dalam kueri Anda.

Jika Anda membutuhkan pertanyaan seperti "Beri saya semua 'Klub' yang ... dari setiap 'Orang' yang ..." jangan berpikir untuk bergabung. Sebagai gantinya gunakan ICollections!

Ajak semua orang "John Doe" dengan semua Country club yang mereka hadiri:

var result = myDbContext.Persons
    .Where(person => person.Name == "John Doe")
    .Select(person => new
    {
        PersonId = person.Id,
        PersonName = person.Name,
        AttendedCountryClubs = person.Clubs
            .Where(club => club.Type = ClubType.CountryClub),
    };

Kerangka kerja entitas akan mengenali bahwa gabungan dengan tabel banyak-ke-banyak ekstra diperlukan, dan akan melakukan penggabungan ini, tanpa Anda menyebutkan tabel tambahan ini.

Sebaliknya: Ajak semua country club dengan Person "John Doe" mereka:

var result = myDbContext.Clubs
    .Where(club => club.Type = ClubType.CountryClub)
    .Select(club => new
    {
         ClubId = club.Id,
         ClubName = club.Name,
         AnonymousMembers = club.Persons
             .Where(person => person.Name == "John Doe"),
    }

Saya telah mengalami bahwa begitu saya mulai memikirkan koleksi yang dihasilkan yang saya inginkan alih-alih gabungan yang saya butuhkan untuk mendapatkan koleksi ini, saya menemukan bahwa saya hampir tidak menggunakan gabungan. Ini adalah kasus relasi one-to-many serta many-to-many. Framework entitas secara internal akan menggunakan gabungan yang tepat.