Comment puis-je optimiser les insertions d'Entity Framework pour des performances maximales lorsque je traite de grands ensembles de données ?

Améliorer les performances d'insertion d'Entity Framework avec de grands ensembles de données

L'insertion de grands ensembles de données dans Entity Framework (EF) peut être lente. Cet article explore des techniques permettant d'accélérer considérablement ce processus, en particulier lors de l'utilisation de TransactionScopes et de la gestion d'un nombre important d'enregistrements.

Optimisation des SaveChanges() Appels

La pratique courante consistant à appeler SaveChanges() pour chaque enregistrement est inefficace pour les insertions groupées. Envisagez plutôt ces alternatives :

• Batch SaveChanges() : Appelez SaveChanges() une seule fois après que tous les enregistrements ont été ajoutés au contexte.
• Intervalle SaveChanges() : Appelez SaveChanges() après un nombre défini d'enregistrements (par exemple, 100 ou 1000).
• Recyclage du contexte : Appelez SaveChanges(), supprimez le contexte et créez-en un nouveau après un certain nombre d'enregistrements.

Ces méthodes réduisent les allers-retours dans la base de données et minimisent les frais généraux liés au suivi des modifications.

Mise en œuvre efficace des insertions en masse

Le code suivant illustre l'insertion groupée optimisée :

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

Cet exemple désactive la détection automatique des modifications (AutoDetectChangesEnabled = false) pour des gains de performances. La méthode AddToContext gère la validation des modifications et éventuellement la recréation du contexte après un nombre spécifié d'enregistrements.

Résultats de référence

Les tests effectués sur 560 000 enregistrements ont montré des améliorations spectaculaires :

• Par enregistrement SaveChanges() : Heures
• SaveChanges() après 100 enregistrements : Plus de 20 minutes
• SaveChanges() après 1000 enregistrements (pas d'élimination du contexte) : 242 secondes
• SaveChanges() après 1000 enregistrements (avec élimination du contexte) : 191 secondes

Conclusion

Ces stratégies améliorent considérablement les performances d’insertion en masse d’Entity Framework. La désactivation du suivi des modifications, l'utilisation de lots SaveChanges() et la gestion efficace du contexte sont essentielles pour gérer efficacement de grands ensembles de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!