Entity Framework - Schließen Sie mehrere Eigenschaftenebenen ein

Die Include () -Methode eignet sich sehr gut für Listen für Objekte. Aber was ist, wenn ich zwei Ebenen tief gehen muss? Die folgende Methode gibt beispielsweise ApplicationServer mit den hier gezeigten enthaltenen Eigenschaften zurück. ApplicationsWithOverrideGroup ist jedoch ein weiterer Container, der andere komplexe Objekte enthält. Kann ich auch ein Include () für diese Eigenschaft ausführen? Oder wie kann ich diese Eigenschaft vollständig laden?

So wie es jetzt aussieht, ist diese Methode:

public IEnumerable<ApplicationServer> GetAll()
{
    return this.Database.ApplicationServers
        .Include(x => x.ApplicationsWithOverrideGroup)                
        .Include(x => x.ApplicationWithGroupToForceInstallList)
        .Include(x => x.CustomVariableGroups)                
        .ToList();
}

Füllt nur die Enabled-Eigenschaft (unten) und nicht die Application- oder CustomVariableGroup-Eigenschaften (unten). Wie mache ich das möglich?

public class ApplicationWithOverrideVariableGroup : EntityBase
{
    public bool Enabled { get; set; }
    public Application Application { get; set; }
    public CustomVariableGroup CustomVariableGroup { get; set; }
}

Für EF 6

using System.Data.Entity;

query.Include(x => x.Collection.Select(y => y.Property))

Stellen Sie sicher, dass Sie hinzufügen using System.Data.Entity;, um die Version zu erhalten Include, die ein Lambda enthält.

Für EF Core

Verwenden Sie die neue Methode ThenInclude

query.Include(x => x.Collection)
     .ThenInclude(x => x.Property);

Wenn ich Sie richtig verstehe, fragen Sie nach verschachtelten Eigenschaften. Wenn ja :

.Include(x => x.ApplicationsWithOverrideGroup.NestedProp)

oder

.Include("ApplicationsWithOverrideGroup.NestedProp")  

oder

.Include($"{nameof(ApplicationsWithOverrideGroup)}.{nameof(NestedProp)}")  

EF Core: Verwenden von "ThenInclude" zum Laden mehrerer Ebenen: Zum Beispiel:

var blogs = context.Blogs
    .Include(blog => blog.Posts)
        .ThenInclude(post => post.Author)
        .ThenInclude(author => author.Photo)
    .ToList();

Ich habe einen kleinen Helfer für Entity Framework 6 (.Net Core-Stil) erstellt, um Unterentitäten auf nette Weise einzuschließen.

Es ist jetzt auf NuGet: Install-Package ThenInclude.EF6

using System.Data.Entity;

var thenInclude = context.One.Include(x => x.Twoes)
    .ThenInclude(x=> x.Threes)
    .ThenInclude(x=> x.Fours)
    .ThenInclude(x=> x.Fives)
    .ThenInclude(x => x.Sixes)
    .Include(x=> x.Other)
    .ToList();

Das Paket ist auf GitHub verfügbar .

Weitere EFCore-Beispiele auf MSDN zeigen, dass Sie mit Includeund einige recht komplexe Dinge tun können ThenInclude.

Dies ist ein gutes Beispiel dafür, wie komplex Sie werden können (dies ist alles eine Aussage!):

viewModel.Instructors = await _context.Instructors

      .Include(i => i.OfficeAssignment)

      .Include(i => i.CourseAssignments)
        .ThenInclude(i => i.Course)
            .ThenInclude(i => i.Enrollments)
                .ThenInclude(i => i.Student)

      .Include(i => i.CourseAssignments)
        .ThenInclude(i => i.Course)
            .ThenInclude(i => i.Department)

      .AsNoTracking()
      .OrderBy(i => i.LastName)
      .ToListAsync();

Sehen Sie, wie Sie Includeauch danach ThenIncludeverketten können, und es setzt Sie auf die Ebene der Entität der obersten Ebene (Instruktoren) zurück.

Sie können dieselbe Sammlung der ersten Ebene (CourseAssignments) sogar mehrmals wiederholen, gefolgt von separaten ThenIncludesBefehlen, um zu verschiedenen untergeordneten Entitäten zu gelangen.

Beachten Sie, dass Ihre eigentliche Abfrage am Ende der Kette Includeoder markiert sein muss ThenIncludes. Folgendes funktioniert NICHT:

var query = _context.Instructors.AsQueryable();
query.Include(i => i.OfficeAssignment);

var first10Instructors = query.Take(10).ToArray();

Ich würde Ihnen dringend empfehlen, die Protokollierung einzurichten und sicherzustellen, dass Ihre Abfragen nicht außer Kontrolle geraten, wenn Sie mehr als ein oder zwei Dinge einbeziehen. Es ist wichtig zu sehen, wie es tatsächlich funktioniert - und Sie werden feststellen, dass jedes einzelne "Include" normalerweise eine neue Abfrage ist, um zu vermeiden, dass massive Joins redundante Daten zurückgeben.

AsNoTracking Dies kann die Arbeit erheblich beschleunigen, wenn Sie nicht beabsichtigen, die Entitäten tatsächlich zu bearbeiten und erneut zu speichern.

Ich musste auch mehrere Includes verwenden und auf der 3. Ebene brauchte ich mehrere Eigenschaften

(from e in context.JobCategorySet
                      where e.Id == id &&
                            e.AgencyId == agencyId
                      select e)
                      .Include(x => x.JobCategorySkillDetails)
                      .Include(x => x.Shifts.Select(r => r.Rate).Select(rt => rt.DurationType))
                      .Include(x => x.Shifts.Select(r => r.Rate).Select(rt => rt.RuleType))
                      .Include(x => x.Shifts.Select(r => r.Rate).Select(rt => rt.RateType))
                      .FirstOrDefaultAsync();

Das kann jemandem helfen :)

Lassen Sie mich klarstellen, dass Sie die Zeichenfolgenüberladung verwenden können, um verschachtelte Ebenen unabhängig von der Vielzahl der entsprechenden Beziehungen einzuschließen, wenn Sie nichts dagegen haben, Zeichenfolgenliterale zu verwenden:

query.Include("Collection.Property")