Wie kann ich Entity Framework-Einfügungen für maximale Leistung beim Umgang mit großen Datensätzen optimieren?

Steigerung der Entity Framework-Einfügeleistung bei großen Datensätzen

Das Einfügen großer Datensätze in Entity Framework (EF) kann langsam sein. In diesem Artikel werden Techniken zur erheblichen Beschleunigung dieses Prozesses untersucht, insbesondere bei Verwendung von TransactionScopes und der Verarbeitung einer erheblichen Anzahl von Datensätzen.

Optimierung von SaveChanges()Anrufen

Die übliche Praxis, SaveChanges() für jeden Datensatz aufzurufen, ist für Masseneinfügungen ineffizient. Ziehen Sie stattdessen diese Alternativen in Betracht:

• Batch SaveChanges(): Rufen Sie SaveChanges() nur einmal auf, nachdem alle Datensätze dem Kontext hinzugefügt wurden.
• Intervall SaveChanges(): Aufruf SaveChanges() nach einer festgelegten Anzahl von Datensätzen (z. B. 100 oder 1000).
• Kontext-Recycling: Rufen Sie SaveChanges() auf, entsorgen Sie den Kontext und erstellen Sie nach einer bestimmten Anzahl von Datensätzen einen neuen.

Diese Methoden reduzieren Datenbank-Roundtrips und minimieren den Aufwand durch die Änderungsverfolgung.

Effiziente Masseneinfügungsimplementierung

Der folgende Code demonstriert die optimierte Masseneinfügung:

<code class="language-csharp">using (TransactionScope scope = new TransactionScope())
{
    MyDbContext context = null;
    try
    {
        context = new MyDbContext();
        context.Configuration.AutoDetectChangesEnabled = false;

        int count = 0;
        foreach (var entityToInsert in someCollectionOfEntitiesToInsert)
        {
            ++count;
            context = AddToContext(context, entityToInsert, count, 1000, true);
        }

        context.SaveChanges();
    }
    finally
    {
        if (context != null)
            context.Dispose();
    }

    scope.Complete();
}

private MyDbContext AddToContext(MyDbContext context, Entity entity, int count, int commitCount, bool recreateContext)
{
    context.Set<Entity>().Add(entity);

    if (count % commitCount == 0)
    {
        context.SaveChanges();
        if (recreateContext)
        {
            context.Dispose();
            context = new MyDbContext();
            context.Configuration.AutoDetectChangesEnabled = false;
        }
    }

    return context;
}</code>

In diesem Beispiel wird die automatische Änderungserkennung (AutoDetectChangesEnabled = false) zur Leistungssteigerung deaktiviert. Die AddToContext-Methode übernimmt das Festschreiben von Änderungen und optional die Neuerstellung des Kontexts nach einer angegebenen Anzahl von Datensätzen.

Benchmark-Ergebnisse

Tests mit 560.000 Datensätzen zeigten dramatische Verbesserungen:

• Pro Datensatz SaveChanges(): Stunden
• SaveChanges()nach 100 Datensätzen: Über 20 Minuten
• SaveChanges() nach 1000 Datensätzen (keine Kontextentfernung): 242 Sekunden
• SaveChanges() nach 1000 Datensätzen (mit Kontextentsorgung): 191 Sekunden

Fazit

Diese Strategien verbessern die Leistung von Entity Framework-Masseneinfügungen erheblich. Das Deaktivieren der Änderungsverfolgung, die Verwendung von Batch SaveChanges() und die effektive Verwaltung des Kontexts sind der Schlüssel zur effizienten Verarbeitung großer Datenmengen.

Das obige ist der detaillierte Inhalt vonWie kann ich Entity Framework-Einfügungen für maximale Leistung beim Umgang mit großen Datensätzen optimieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!