Entity-framework-code ist sehr langsam, wenn mit Include() um ein Vielfaches

Ich habe einige debugging-slow-code, und es scheint, dass der Täter ist die EF code unten geschrieben. Es dauert 4-5 Sekunden, wenn die Abfrage ausgewertet wird zu einem späteren Zeitpunkt. Ich versuche es in unter 1 Sekunde.

Habe ich getestet, mit der SQL Server Profiler, und es scheint, dass eine Reihe von SQL-Skripts ausgeführt werden. Es bestätigt auch, dass es dauert 3-4 Sekunden, bevor Sie SQL server erfolgt mit den Hinrichtungen.

Ich habe gelesen, ähnliche Fragen über die Verwendung von Include() und es scheint, dass es ein performance-Einbußen, wenn es zu benutzen. Ich habe versucht, den split den untenstehenden code in mehrere verschiedene Abfragen, aber es ist nicht so viel Unterschied.

Irgendeine Idee, wie ich die unten schneller ausführen?

Derzeit die web-app, die ich arbeite, ist nur mit einer leeren iframe während der Wartezeit für die unten zu vervollständigen. Wenn ich nicht schneller Ausführung mal habe ich es aufgeteilt und teilweise laden des iframe mit Daten oder mit anderen asynchrone Lösung. Alle Ideen, die hier auch gewürdigt werden!

using (var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted }))
        {
            formInstance = context.FormInstanceSet
                                .Includes(x => x.Include(fi => fi.FormDefinition).Include(fd => fd.FormSectionDefinitions).Include(fs => fs.FormStateDefinitionEditableSections))
                                .Includes(x => x.Include(fi => fi.FormDefinition).Include(fd => fd.FormStateDefinitions))
                                .Includes(x => x.Include(fi => fi.FormSectionInstances).Include(fs => fs.FormFieldInstances).Include(ff => ff.FormFieldDefinition).Include(ffd => ffd.FormFieldMetaDataDefinition).Include(ffmdd => ffmdd.ComplexTypePropertyNames))
                                .Include(x => x.CurrentFormStateInstance)      
                                .Include(x => x.Files)
                                .FirstOrDefault(x => x.FormInstanceIdentifier == formInstanceIdentifier);

            scope.Complete();
        }
  • Was ist Beinhaltet(mit 's')? Ist es eine proprietäre Erweiterung?
  • Ich glaube, es war eine Erweiterung Methode zur Kette gehören unter anderem, wenn das Sinn macht. Ich habe keinen Zugriff auf den code nicht mehr, so kann ich Ihnen nicht genau sagen, was es war, aber das ist meine beste Vermutung, von was ich mich erinnere.
InformationsquelleAutor DSF | 2016-01-11
  1. 52

    scheint es, dass es Leistungseinbußen bei der Verwendung von Include -

    Das ist eine Untertreibung! Mehrere Includes schnell Blasen bis die SQL-Abfrage Ergebnis sowohl in der Breite und in der Länge. Warum ist das so?

    tl;dr Mehrere Includes Schlag auf den SQL-Ergebnismenge. Bald wird es billiger, Daten zu laden, indem Sie mehrere Datenbank-Aufrufe, anstatt eine mega-Anweisung. Versuchen zu finden die beste Mischung aus Include und Load Aussagen.

    Wachstum Faktor Includes

    Sagen wir, wir haben

    • root-entity Root
    • übergeordneten Entität Root.Parent
    • untergeordnete Entitäten Root.Children1 und Root.Children2
    • eine LINQ-Anweisung Root.Include("Parent").Include("Children1").Include("Children2")

    Diese baut eine SQL-Anweisung, die folgende Struktur hat:

    SELECT *, <PseudoColumns>
FROM Root
JOIN Parent
JOIN Children1

UNION

SELECT *, <PseudoColumns>
FROM Root
JOIN Parent
JOIN Children2

    Diese <PseudoColumns> bestehen aus Ausdrücken wie CAST(NULL AS int) AS [C2], - und dienen Sie um die gleiche Anzahl von Spalten in allen UNION-ed-Abfragen. Der erste Teil fügt pseudo-Spalten für Child2, der zweite Teil fügt pseudo-Spalten für Child1.

    Dies ist, was es bedeutet, für die Größe der SQL-Ergebnismenge:

    • Anzahl der Spalten in der SELECT - Klausel ist die Summe aller Spalten, die in den vier Tabellen
    • Die Anzahl der Zeilen ist die Summe der Datensätze in der untergeordneten Auflistungen

    Da die Gesamtzahl der Datenpunkte ist columns * rows, jede weitere Include exponentiell steigt die Gesamtzahl der Datenpunkte in der Ergebnismenge. Lassen Sie mich demonstrieren, dass durch die Einnahme von Root wieder, jetzt mit einer zusätzlichen Children3 Sammlung. Wenn alle Tabellen sind in 5 Spalten und 100 Zeilen, erhalten wir:

    Einer Include (Root + 1 Kind Kollektion): 10 Spalten * 100 Zeilen = 1000 Datenpunkten.

    Zwei Includes (Root + 2 Kind Sammlungen): 15 Spalten * 200 Zeilen = 3000 data points.

    Drei Includes (Root + 3 Kind Sammlungen): 20 Spalten * 300 Reihen = 6000 Datenpunkte.

    Mit 12 Includes wären das 78000 Daten Punkte!

    Umgekehrt, wenn man alle Datensätze für jede Tabelle separat statt 12 Includes Sie haben 13 * 5 * 100 Daten Punkte: 6500, weniger als 10%!

    Nun diese zahlen sind etwas übertrieben, dass viele dieser Daten werden die Punkte null, so dass Sie nicht viel dazu beitragen, um die tatsächliche Größe der Ergebnismenge, die an den client gesendet wird. Aber die Abfrage der Größe und der Aufgabe der query optimizer sicherlich negativ beeinflusst durch die zunehmende Zahl von Includes.

    Balance

    Also mit Includes ist eine heikle balance zwischen den Kosten der Datenbank-Aufrufe und Daten-Volumen. Es ist schwer zu geben, eine Faustregel, aber jetzt können Sie sich vorstellen, dass sich das Datenvolumen in der Regel schnell über die Kosten für zusätzliche Anrufe, wenn es mehr als ~3 Includes für Kinder-Kollektionen (aber schon ein bisschen mehr für die Eltern Includes, dass nur erweitern die Ergebnismenge).

    Alternative

    Die alternative zu Include ist zum laden von Daten in separate Abfragen:

    context.Configuration.LazyLoadingEnabled = false;
var rootId = 1;
context.Children1.Where(c => c.RootId == rootId).Load();
context.Children2.Where(c => c.RootId == rootId).Load();
return context.Roots.Find(rootId);

    Dieser lädt alle benötigten Daten in den Kontext des cache. Während dieses Prozesses, EF führt Beziehung Korrektur, durch die es automatisch füllt navigation Eigenschaften (Root.Children etc.) von geladenen Entitäten. Das Endergebnis ist identisch zu der Anweisung mit Includes, außer einem wichtigen Unterschied: das Kind Sammlungen sind nicht gekennzeichnet als geladen in der entity-state-manager, so dass EF wird versuchen, die trigger lazy loading, wenn Sie auf Sie. Deshalb ist es wichtig, schalten Sie lazy loading.

    In der Realität, die Sie haben, um herauszufinden, welche Kombination von Include und Load Aussagen, die am besten für Sie arbeiten.

    InformationsquelleAutor Gert Arnold
  2. 0

    Tun Sie richtig konfiguriert haben, die Beziehungen zwischen allen Entitäten, die Sie versuchen zu 'gehören'? Wenn mindestens eine Person nicht über eine Beziehung zu einigen der anderen Unternehmen, dann ist EF nicht in der Lage zu konstruieren, die eine komplexe Abfrage mit SQL join-syntax - sondern es wird ausgeführt, wie viele Abfragen, wie viele 'schließt' Sie haben. Und natürlich, das führt zu performance-Problemen. Könnten Sie bitte nach den genauen query(-es), das EF generiert, um die Daten zu erhalten?

    • Es gibt ungefähr 20-30! Weist das auf ein problem mit der Abfrage?
    • Ich glaube, das bedeutet, dass Sie nicht die richtige Fremdschlüssel in der Datenbank oder nicht korrekt konfiguriert Beziehungen während Ihrer DbContext-Erstellung im Fall von Modell-First-Ansatz (OnModelCreating-Methode). Ideal, wenn Sie alle Beziehungen richtig konfiguriert ist, müssen Sie die Abfrage mit vielen joins. So, das ist nicht ein problem mit einer Abfrage, anstatt mit der Datenbank-Struktur.
    • Ich habe bemerkt, dass ausländische keys nicht definiert sind, zwischen einige der Tabellen. So hat es einen großen Einfluss auf den tatsächlichen SQL generiert wird?
    • Kann ich irgendwo Lesen über diese? I. e. fehlende Fremdschlüssel führt zu übermäßigen generierte sql von EF ? BTW die webapp wurde mit DB-ersten.
    • Versuchen Sie zu Lesen dieser. Im Falle von DatabaseFirst, mit den richtigen Fremdschlüssel ist extrem wichtig. Sonst EF nicht in der Lage, um die Beziehungen zwischen Entitäten und, als Ergebnis, wird nicht in der Lage zu bauen, eine richtige Abfrage. Beispiel: Sie haben Benutzer-und Gruppen-Tabellen ohne FK zwischen Ihnen. Dann, mit Hilfe der Include-Anweisung in C#, wie EF weiß, dass sagen, Benutzer a ist Mitglied von Gruppe1? Es wird einfach erzeugen zwei Abfragen: ein, um alle Benutzer, eine andere zu bekommen alle Gruppen...
    • Ein weiterer Vorschlag (als Sie sagten, Sie haben keine FKs zwischen den Tabellen, aber das bedeutet, dass Sie haben Sie zwischen anderen) - versuchen Sie, verwenden Sie Include() nur für Tabellen, die FKs zwischen Ihnen. In diesem Fall EF generieren soll nur eine Abfrage. Wenn das nicht hilft, auch - versuchen, um das Modell zu reparieren in Ihrem edmx hinzufügen von Beziehungen.
    • Es scheint, dass in der edmx-die Beziehungen sind richtig definiert, aber ein Blick in die DB selbst, d.h. im SQL Management Studio, DB -> Tabellen -> Schlüssel gibt es keine Fremdschlüssel definiert werden für einige Tabellen, aber für andere gibt es... Kann diese Inkonsistenz zu einem problem werden zu? Oder ist es ausreichend, um Ihre Beziehungen definiert, in der edmx nur ?
    • Versuchen Sie, eine Abfrage mit 2 oder max 3 Tabellen (mittels include-Anweisung), die Beziehungen definiert. Wenn am Ende musst du nur ein SQL - query versuchen, fügen Sie weitere Tabellen, die man von einem entscheidenden die, die die Probleme verursacht. Sonst, überprüfen Sie die edmx - vielleicht Beziehungen sind nicht korrekt definiert (ich meine, Sie spiegeln nicht die Reale Struktur der Datenbank). Im Grunde, wenn Beziehungen sind korrekt definiert sind, wird die include-Anweisung generiert nur eine SQL-Abfrage mit den entsprechenden Verknüpfungen.

    InformationsquelleAutor drcolombo
Schreibe einen Kommentar