Fluent-API, viele-zu-viele in Entity Framework-Core

Ist dies noch nicht möglich EF-Kern ohne eine explizite Klasse, die für die Verknüpfung. Sehen hier ein Beispiel dafür, wie das zu tun.

Es ist ein offenes Problem auf Github Fragen, für die Fähigkeit, dies zu tun, ohne die Notwendigkeit für eine explizite Klasse, aber es ist noch nicht abgeschlossen.

Mit Ihrem Szenario, das Beispiel, das ich verlinkt würde empfehlen, die folgenden entity-Klassen:

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

Den folgenden OnModelCreating wäre dann für die Installation verwendet:

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

Sicher sein, zu gehen, um die offene Frage, die ich verlinkte und Stimme, Ihre frustration, wenn Sie das Bedürfnis verspüren.

EDIT: Die Frage suggeriert die Verwendung einer einfachen Select zum navigieren durch diese etwas schwerfällige Hierarchie. Um von einem PersonId eine Sammlung von Clubs, die Sie verwenden können,SelectMany. z.B.:

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

Kann ich nicht bürgen, ob dies wirklich eine "best practice", aber es sollte sicherlich den trick tun und ich denke seine fair zu sagen, es ist nicht übermäßig hässlich.

InformationsquelleAutor Kirk Larkin

Also jeden Person hat null oder mehr Clubs und jeder Club hat null oder mehr Persons. Wie Sie richtig feststellte, ist dies ein richtigen viele-zu-viele-Beziehung.

Wissen Sie wahrscheinlich, dass eine relationale Datenbank benötigt eine extra Tabelle zu implementieren, der diese viele-zu-viele-Beziehung. Die nette Sache über entity framework ist, dass es erkennt diese Beziehung und legt diese extra-Tisch für Sie.

Auf den ersten Blick scheint es ein problem, dass diese zusätzliche Tabelle ist nicht dbSet in Ihrem DbContext: "Wie führen Sie einen join mit diesem extra Tabelle, wenn ich nicht DbSet für Sie?".

Zum Glück, Sie brauchen nicht zu erwähnen, das extra-Tabelle in den Anfragen benötigt.

Wenn du eine Abfrage wie "Gib mir alle Clubs', die ... von jeder 'Person', die ..." glaube nicht, dass in den joins. Verwenden Sie stattdessen die ICollections!

Bekommen alle "John Doe" Personen mit all Country clubs, die Sie besuchen:

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

Entity framework erkennt, dass eine Verknüpfung mit der extra viele-zu-viele-Tabelle ist erforderlich, und wird dieser join ausgeführt wird, ohne Sie zu erwähnen, diese extra Tabelle.

Umgekehrt: Holen Sie sich alle country-clubs mit Ihren "John Doe" Personen:

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"),
    }

Habe ich erlebt, dass, sobald ich begann zu denken, die daraus resultierenden Kollektionen, die ich will, anstatt die Verknüpfungen, die ich brauchte, um diese Sammlungen fand ich, dass ich kaum verwenden, die verbindet. Dies ist der Fall für eins-zu-viele Beziehungen, wie auch die viele-zu-viele-Beziehungen. Entity framework intern mit dem richtigen verbindet.

InformationsquelleAutor Harald Coppoolse