Je cherche le moyen le plus rapide d'insérer dans Entity Framework.

Je pose cette question en raison du scénario dans lequel vous avez un TransactionScope actif et l'insertion est énorme (4000+). Cela peut potentiellement durer plus de 10 minutes (délai d'expiration par défaut des transactions), ce qui entraînera une transaction incomplète.

À votre remarque dans les commentaires à votre question:

"... SavingChanges ( pour chaque enregistrement ) ..."

C'est la pire chose que vous puissiez faire! L'appel SaveChanges()pour chaque enregistrement ralentit considérablement les insertions en masse. Je ferais quelques tests simples qui amélioreront très probablement les performances:

• Appelez SaveChanges()une fois après TOUS les enregistrements.
• Appelez SaveChanges()par exemple 100 enregistrements.
• Appelez SaveChanges()par exemple 100 enregistrements et supprimez le contexte et créez-en un nouveau.
• Désactiver la détection des modifications

Pour les insertions en masse, je travaille et expérimente avec un modèle comme celui-ci:

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

J'ai un programme de test qui insère 560 000 entités (9 propriétés scalaires, pas de propriétés de navigation) dans la base de données. Avec ce code, il fonctionne en moins de 3 minutes.

Pour les performances, il est important d'appeler SaveChanges()après "plusieurs" enregistrements ("plusieurs" autour de 100 ou 1000). Il améliore également les performances pour éliminer le contexte après SaveChanges et en créer un nouveau. Cela efface le contexte de toutes les entités, SaveChangesne fait pas cela, les entités sont toujours attachées au contexte dans l'état Unchanged. C'est la taille croissante des entités attachées dans le contexte qui ralentit l'insertion pas à pas. Il est donc utile de l'effacer après un certain temps.

Voici quelques mesures pour mes 560000 entités:

• commitCount = 1, recreateContext = false: plusieurs heures (c'est votre procédure actuelle)
• commitCount = 100, recreateContext = false: plus de 20 minutes
• commitCount = 1000, recreateContext = false: 242 sec
• commitCount = 10000, recréerContexte = false: 202 sec
• commitCount = 100000, recreateContext = false: 199 sec
• commitCount = 1000000, recreateContext = false: exception de mémoire insuffisante
• commitCount = 1, recreateContext = true: plus de 10 minutes
• commitCount = 10, recreateContext = true: 241 sec
• commitCount = 100, recreateContext = true: 164 sec
• commitCount = 1000, recreateContext = true: 191 sec

Le comportement dans le premier test ci-dessus est que les performances sont très non linéaires et diminuent extrêmement au fil du temps. ("Plusieurs heures" est une estimation, je n'ai jamais terminé ce test, je me suis arrêté à 50 000 entités après 20 minutes.) Ce comportement non linéaire n'est pas si significatif dans tous les autres tests.

Cette combinaison augmente assez bien la vitesse.

context.Configuration.AutoDetectChangesEnabled = false;
context.Configuration.ValidateOnSaveEnabled = false;

Le moyen le plus rapide serait d'utiliser l' extension d'insertion en vrac , que j'ai développée

note: ceci est un produit commercial, non gratuit

Il utilise SqlBulkCopy et un datareader personnalisé pour obtenir des performances maximales. En conséquence, il est plus de 20 fois plus rapide que l'utilisation de l'insertion régulière ou AddRange

l'utilisation est extrêmement simple

context.BulkInsert(hugeAmountOfEntities);

Vous devriez envisager d'utiliser le System.Data.SqlClient.SqlBulkCopypour cela. Voici la documentation , et bien sûr, il existe de nombreux tutoriels en ligne.

Désolé, je sais que vous cherchiez une réponse simple pour que EF fasse ce que vous voulez, mais les opérations en bloc ne sont pas vraiment ce à quoi les ORM sont destinés.

Je suis d'accord avec Adam Rackis. SqlBulkCopyest le moyen le plus rapide de transférer des enregistrements en vrac d'une source de données à une autre. Je l'ai utilisé pour copier 20 000 enregistrements et cela a pris moins de 3 secondes. Jetez un œil à l'exemple ci-dessous.

public static void InsertIntoMembers(DataTable dataTable)
{           
    using (var connection = new SqlConnection(@"data source=;persist security info=True;user id=;password=;initial catalog=;MultipleActiveResultSets=True;App=EntityFramework"))
    {
        SqlTransaction transaction = null;
        connection.Open();
        try
        {
            transaction = connection.BeginTransaction();
            using (var sqlBulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.TableLock, transaction))
            {
                sqlBulkCopy.DestinationTableName = "Members";
                sqlBulkCopy.ColumnMappings.Add("Firstname", "Firstname");
                sqlBulkCopy.ColumnMappings.Add("Lastname", "Lastname");
                sqlBulkCopy.ColumnMappings.Add("DOB", "DOB");
                sqlBulkCopy.ColumnMappings.Add("Gender", "Gender");
                sqlBulkCopy.ColumnMappings.Add("Email", "Email");

                sqlBulkCopy.ColumnMappings.Add("Address1", "Address1");
                sqlBulkCopy.ColumnMappings.Add("Address2", "Address2");
                sqlBulkCopy.ColumnMappings.Add("Address3", "Address3");
                sqlBulkCopy.ColumnMappings.Add("Address4", "Address4");
                sqlBulkCopy.ColumnMappings.Add("Postcode", "Postcode");

                sqlBulkCopy.ColumnMappings.Add("MobileNumber", "MobileNumber");
                sqlBulkCopy.ColumnMappings.Add("TelephoneNumber", "TelephoneNumber");

                sqlBulkCopy.ColumnMappings.Add("Deleted", "Deleted");

                sqlBulkCopy.WriteToServer(dataTable);
            }
            transaction.Commit();
        }
        catch (Exception)
        {
            transaction.Rollback();
        }

    }
}

Je recommanderais cet article sur la façon de faire des insertions en masse à l'aide d'EF.

Entity Framework et INSERTS en vrac lents

Il explore ces domaines et compare les performances:

1. EF par défaut (57 minutes pour terminer l'ajout de 30 000 enregistrements)
2. Remplacement par le code ADO.NET (25 secondes pour ces mêmes 30 000)
3. Contournement du contexte - Gardez le graphique de contexte actif petit en utilisant un nouveau contexte pour chaque unité de travail (les mêmes 30 000 insertions prennent 33 secondes)
4. Grandes listes - Désactivez AutoDetectChangesEnabled (réduit le temps à environ 20 secondes)
5. Batching (jusqu'à 16 secondes)
6. DbTable.AddRange () - (les performances sont de l'ordre de 12)

comme cela n'a jamais été mentionné ici, je veux recommander EFCore.BulkExtensions ici

context.BulkInsert(entitiesList);                 context.BulkInsertAsync(entitiesList);
context.BulkUpdate(entitiesList);                 context.BulkUpdateAsync(entitiesList);
context.BulkDelete(entitiesList);                 context.BulkDeleteAsync(entitiesList);
context.BulkInsertOrUpdate(entitiesList);         context.BulkInsertOrUpdateAsync(entitiesList);         // Upsert
context.BulkInsertOrUpdateOrDelete(entitiesList); context.BulkInsertOrUpdateOrDeleteAsync(entitiesList); // Sync
context.BulkRead(entitiesList);                   context.BulkReadAsync(entitiesList);

J'ai enquêté sur la réponse de Slauma (ce qui est génial, merci pour l'idée homme), et j'ai réduit la taille des lots jusqu'à ce que j'atteigne la vitesse optimale. En regardant les résultats de Slauma:

• commitCount = 1, recreateContext = true: plus de 10 minutes
• commitCount = 10, recreateContext = true: 241 sec
• commitCount = 100, recreateContext = true: 164 sec
• commitCount = 1000, recreateContext = true: 191 sec

Il est visible qu'il y a une augmentation de la vitesse lors du passage de 1 à 10 et de 10 à 100, mais de 100 à 1000, la vitesse d'insertion diminue à nouveau.

Je me suis donc concentré sur ce qui se passe lorsque vous réduisez la taille du lot à une valeur comprise entre 10 et 100, et voici mes résultats (j'utilise différents contenus de ligne, donc mes temps ont une valeur différente):

Quantity    | Batch size    | Interval
1000    1   3
10000   1   34
100000  1   368

1000    5   1
10000   5   12
100000  5   133

1000    10  1
10000   10  11
100000  10  101

1000    20  1
10000   20  9
100000  20  92

1000    27  0
10000   27  9
100000  27  92

1000    30  0
10000   30  9
100000  30  92

1000    35  1
10000   35  9
100000  35  94

1000    50  1
10000   50  10
100000  50  106

1000    100 1
10000   100 14
100000  100 141

Sur la base de mes résultats, l'optimum réel est d'environ 30 pour la taille du lot. C'est moins que 10 et 100. Le problème, c'est que je n'ai aucune idée de pourquoi 30 est optimal, et je n'aurais pas pu trouver d'explication logique à cela.

Comme d'autres l'ont dit, SqlBulkCopy est le moyen de le faire si vous voulez de très bonnes performances d'insertion.

C'est un peu lourd à mettre en œuvre mais il existe des bibliothèques qui peuvent vous aider. Il y en a quelques-uns mais je débrancherai sans vergogne ma propre bibliothèque cette fois: https://github.com/MikaelEliasson/EntityFramework.Utilities#batch-insert-entities

Le seul code dont vous auriez besoin est:

 using (var db = new YourDbContext())
 {
     EFBatchOperation.For(db, db.BlogPosts).InsertAll(list);
 }

Alors, c'est beaucoup plus rapide? Très difficile à dire parce que cela dépend de nombreux facteurs, la performance des ordinateurs, réseau, la taille des objets etc etc Les tests de performance que j'ai fait suggère 25k entités peuvent être insérées à environ 10s la manière standard sur localhost Si vous optimisez votre configuration EF comme mentionné dans les autres réponses. Avec EFUtilities, cela prend environ 300 ms. Encore plus intéressant, j'ai enregistré environ 3 millions d'entités en moins de 15 secondes en utilisant cette méthode, en moyenne environ 200 000 entités par seconde.

Le seul problème est bien sûr si vous devez insérer des données recréées. Cela peut être fait efficacement sur le serveur SQL à l'aide de la méthode ci-dessus, mais cela nécessite que vous ayez une stratégie de génération d'ID qui vous permette de générer des ID dans le code d'application pour le parent afin que vous puissiez définir les clés étrangères. Cela peut être fait en utilisant des GUID ou quelque chose comme la génération d'ID HiLo.

Dispose()le contexte crée des problèmes si les entités Add()sur lesquelles vous comptez sur d'autres entités préchargées (par exemple, les propriétés de navigation) dans le contexte

J'utilise un concept similaire pour garder mon contexte petit pour obtenir les mêmes performances

Mais au lieu du Dispose()contexte et recréer, je détache simplement les entités qui déjàSaveChanges()

public void AddAndSave<TEntity>(List<TEntity> entities) where TEntity : class {

const int CommitCount = 1000; //set your own best performance number here
int currentCount = 0;

while (currentCount < entities.Count())
{
    //make sure it don't commit more than the entities you have
    int commitCount = CommitCount;
    if ((entities.Count - currentCount) < commitCount)
        commitCount = entities.Count - currentCount;

    //e.g. Add entities [ i = 0 to 999, 1000 to 1999, ... , n to n+999... ] to conext
    for (int i = currentCount; i < (currentCount + commitCount); i++)        
        _context.Entry(entities[i]).State = System.Data.EntityState.Added;
        //same as calling _context.Set<TEntity>().Add(entities[i]);       

    //commit entities[n to n+999] to database
    _context.SaveChanges();

    //detach all entities in the context that committed to database
    //so it won't overload the context
    for (int i = currentCount; i < (currentCount + commitCount); i++)
        _context.Entry(entities[i]).State = System.Data.EntityState.Detached;

    currentCount += commitCount;
} }

envelopper avec try catch et TrasactionScope()si vous en avez besoin, ne pas les montrer ici pour garder le code propre

Je sais que c'est une très vieille question, mais un gars ici a dit avoir développé une méthode d'extension pour utiliser l'insertion en vrac avec EF, et quand j'ai vérifié, j'ai découvert que la bibliothèque coûte 599 $ aujourd'hui (pour un développeur). Peut-être que cela a du sens pour toute la bibliothèque, mais pour l'insertion en bloc, c'est trop.

Voici une méthode d'extension très simple que j'ai faite. Je l'utilise d'abord sur une paire avec une base de données (ne testez pas d'abord avec le code, mais je pense que cela fonctionne de la même manière). Changez YourEntitiesavec le nom de votre contexte:

public partial class YourEntities : DbContext
{
    public async Task BulkInsertAllAsync<T>(IEnumerable<T> entities)
    {
        using (var conn = new SqlConnection(Database.Connection.ConnectionString))
        {
            await conn.OpenAsync();

            Type t = typeof(T);

            var bulkCopy = new SqlBulkCopy(conn)
            {
                DestinationTableName = GetTableName(t)
            };

            var table = new DataTable();

            var properties = t.GetProperties().Where(p => p.PropertyType.IsValueType || p.PropertyType == typeof(string));

            foreach (var property in properties)
            {
                Type propertyType = property.PropertyType;
                if (propertyType.IsGenericType &&
                    propertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                {
                    propertyType = Nullable.GetUnderlyingType(propertyType);
                }

                table.Columns.Add(new DataColumn(property.Name, propertyType));
            }

            foreach (var entity in entities)
            {
                table.Rows.Add(
                    properties.Select(property => property.GetValue(entity, null) ?? DBNull.Value).ToArray());
            }

            bulkCopy.BulkCopyTimeout = 0;
            await bulkCopy.WriteToServerAsync(table);
        }
    }

    public void BulkInsertAll<T>(IEnumerable<T> entities)
    {
        using (var conn = new SqlConnection(Database.Connection.ConnectionString))
        {
            conn.Open();

            Type t = typeof(T);

            var bulkCopy = new SqlBulkCopy(conn)
            {
                DestinationTableName = GetTableName(t)
            };

            var table = new DataTable();

            var properties = t.GetProperties().Where(p => p.PropertyType.IsValueType || p.PropertyType == typeof(string));

            foreach (var property in properties)
            {
                Type propertyType = property.PropertyType;
                if (propertyType.IsGenericType &&
                    propertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                {
                    propertyType = Nullable.GetUnderlyingType(propertyType);
                }

                table.Columns.Add(new DataColumn(property.Name, propertyType));
            }

            foreach (var entity in entities)
            {
                table.Rows.Add(
                    properties.Select(property => property.GetValue(entity, null) ?? DBNull.Value).ToArray());
            }

            bulkCopy.BulkCopyTimeout = 0;
            bulkCopy.WriteToServer(table);
        }
    }

    public string GetTableName(Type type)
    {
        var metadata = ((IObjectContextAdapter)this).ObjectContext.MetadataWorkspace;
        var objectItemCollection = ((ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace));

        var entityType = metadata
                .GetItems<EntityType>(DataSpace.OSpace)
                .Single(e => objectItemCollection.GetClrType(e) == type);

        var entitySet = metadata
            .GetItems<EntityContainer>(DataSpace.CSpace)
            .Single()
            .EntitySets
            .Single(s => s.ElementType.Name == entityType.Name);

        var mapping = metadata.GetItems<EntityContainerMapping>(DataSpace.CSSpace)
                .Single()
                .EntitySetMappings
                .Single(s => s.EntitySet == entitySet);

        var table = mapping
            .EntityTypeMappings.Single()
            .Fragments.Single()
            .StoreEntitySet;

        return (string)table.MetadataProperties["Table"].Value ?? table.Name;
    }
}

Vous pouvez l'utiliser contre n'importe quelle collection qui hérite de IEnumerable, comme ça:

await context.BulkInsertAllAsync(items);

Essayez d'utiliser une procédure stockée qui obtiendra un XML des données que vous souhaitez insérer.

J'ai fait une extension générique de l'exemple de @Slauma ci-dessus;

public static class DataExtensions
{
    public static DbContext AddToContext<T>(this DbContext context, object entity, int count, int commitCount, bool recreateContext, Func<DbContext> contextCreator)
    {
        context.Set(typeof(T)).Add((T)entity);

        if (count % commitCount == 0)
        {
            context.SaveChanges();
            if (recreateContext)
            {
                context.Dispose();
                context = contextCreator.Invoke();
                context.Configuration.AutoDetectChangesEnabled = false;
            }
        }
        return context;
    }
}

Usage:

public void AddEntities(List<YourEntity> entities)
{
    using (var transactionScope = new TransactionScope())
    {
        DbContext context = new YourContext();
        int count = 0;
        foreach (var entity in entities)
        {
            ++count;
            context = context.AddToContext<TenancyNote>(entity, count, 100, true,
                () => new YourContext());
        }
        context.SaveChanges();
        transactionScope.Complete();
    }
}

Je cherche le moyen le plus rapide d'insérer dans Entity Framework

Certaines bibliothèques tierces prenant en charge l'insertion en bloc sont disponibles:

• Z.EntityFramework.Extensions ( recommandé )
• EFUtilities
• EntityFramework.BulkInsert

Voir: Bibliothèque d'insertion en bloc Entity Framework

Soyez prudent lorsque vous choisissez une bibliothèque d'insertion en bloc. Seules les extensions Entity Framework prennent en charge toutes sortes d'associations et d'héritages et c'est la seule encore prise en charge.

Avis de non - responsabilité : je suis le propriétaire des extensions d' entité Framework

Cette bibliothèque vous permet d'effectuer toutes les opérations en bloc dont vous avez besoin pour vos scénarios:

• Sauvegardes groupées
• Insert en vrac
• Suppression groupée
• Mise à jour en masse
• Fusion en masse

Exemple

// Easy to use
context.BulkSaveChanges();

// Easy to customize
context.BulkSaveChanges(bulk => bulk.BatchSize = 100);

// Perform Bulk Operations
context.BulkDelete(customers);
context.BulkInsert(customers);
context.BulkUpdate(customers);

// Customize Primary Key
context.BulkMerge(customers, operation => {
   operation.ColumnPrimaryKeyExpression = 
        customer => customer.Code;
});

Utilisation SqlBulkCopy:

void BulkInsert(GpsReceiverTrack[] gpsReceiverTracks)
{
    if (gpsReceiverTracks == null)
    {
        throw new ArgumentNullException(nameof(gpsReceiverTracks));
    }

    DataTable dataTable = new DataTable("GpsReceiverTracks");
    dataTable.Columns.Add("ID", typeof(int));
    dataTable.Columns.Add("DownloadedTrackID", typeof(int));
    dataTable.Columns.Add("Time", typeof(TimeSpan));
    dataTable.Columns.Add("Latitude", typeof(double));
    dataTable.Columns.Add("Longitude", typeof(double));
    dataTable.Columns.Add("Altitude", typeof(double));

    for (int i = 0; i < gpsReceiverTracks.Length; i++)
    {
        dataTable.Rows.Add
        (
            new object[]
            {
                    gpsReceiverTracks[i].ID,
                    gpsReceiverTracks[i].DownloadedTrackID,
                    gpsReceiverTracks[i].Time,
                    gpsReceiverTracks[i].Latitude,
                    gpsReceiverTracks[i].Longitude,
                    gpsReceiverTracks[i].Altitude
            }
        );
    }

    string connectionString = (new TeamTrackerEntities()).Database.Connection.ConnectionString;
    using (var connection = new SqlConnection(connectionString))
    {
        connection.Open();
        using (var transaction = connection.BeginTransaction())
        {
            using (var sqlBulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.TableLock, transaction))
            {
                sqlBulkCopy.DestinationTableName = dataTable.TableName;
                foreach (DataColumn column in dataTable.Columns)
                {
                    sqlBulkCopy.ColumnMappings.Add(column.ColumnName, column.ColumnName);
                }

                sqlBulkCopy.WriteToServer(dataTable);
            }
            transaction.Commit();
        }
    }

    return;
}

L'un des moyens les plus rapides pour enregistrer une liste, vous devez appliquer le code suivant

context.Configuration.AutoDetectChangesEnabled = false;
context.Configuration.ValidateOnSaveEnabled = false;

AutoDetectChangesEnabled = false

Add, AddRange & SaveChanges: ne détecte pas les changements.

ValidateOnSaveEnabled = false;

Ne détecte pas le suivi des modifications

Vous devez ajouter nuget

Install-Package Z.EntityFramework.Extensions

Vous pouvez maintenant utiliser le code suivant

var context = new MyContext();

context.Configuration.AutoDetectChangesEnabled = false;
context.Configuration.ValidateOnSaveEnabled = false;

context.BulkInsert(list);
context.BulkSaveChanges();

SqlBulkCopy est super rapide

Voici ma mise en œuvre:

// at some point in my calling code, I will call:
var myDataTable = CreateMyDataTable();
myDataTable.Rows.Add(Guid.NewGuid,tableHeaderId,theName,theValue); // e.g. - need this call for each row to insert

var efConnectionString = ConfigurationManager.ConnectionStrings["MyWebConfigEfConnection"].ConnectionString;
var efConnectionStringBuilder = new EntityConnectionStringBuilder(efConnectionString);
var connectionString = efConnectionStringBuilder.ProviderConnectionString;
BulkInsert(connectionString, myDataTable);

private DataTable CreateMyDataTable()
{
    var myDataTable = new DataTable { TableName = "MyTable"};
// this table has an identity column - don't need to specify that
    myDataTable.Columns.Add("MyTableRecordGuid", typeof(Guid));
    myDataTable.Columns.Add("MyTableHeaderId", typeof(int));
    myDataTable.Columns.Add("ColumnName", typeof(string));
    myDataTable.Columns.Add("ColumnValue", typeof(string));
    return myDataTable;
}

private void BulkInsert(string connectionString, DataTable dataTable)
{
    using (var connection = new SqlConnection(connectionString))
    {
        connection.Open();
        SqlTransaction transaction = null;
        try
        {
            transaction = connection.BeginTransaction();

            using (var sqlBulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.TableLock, transaction))
            {
                sqlBulkCopy.DestinationTableName = dataTable.TableName;
                foreach (DataColumn column in dataTable.Columns) {
                    sqlBulkCopy.ColumnMappings.Add(column.ColumnName, column.ColumnName);
                }

                sqlBulkCopy.WriteToServer(dataTable);
            }
            transaction.Commit();
        }
        catch (Exception)
        {
            transaction?.Rollback();
            throw;
        }
    }
}

[Mise à jour 2019] EF Core 3.1

Suivant ce qui a été dit ci-dessus, la désactivation d'AutoDetectChangesEnabled dans EF Core a parfaitement fonctionné: le temps d'insertion a été divisé par 100 (de plusieurs minutes à quelques secondes, 10 000 enregistrements avec des relations de tables croisées)

Le code mis à jour est:

  context.ChangeTracker.AutoDetectChangesEnabled = false;
            foreach (IRecord record in records) {
               //Add records to your database        
            }
            context.ChangeTracker.DetectChanges();
            context.SaveChanges();
            context.ChangeTracker.AutoDetectChangesEnabled = true; //do not forget to re-enable

Voici une comparaison des performances entre l'utilisation d'Entity Framework et l'utilisation de la classe SqlBulkCopy sur un exemple réaliste: Comment insérer en bloc des objets complexes dans la base de données SQL Server

Comme d'autres l'ont déjà souligné, les ORM ne sont pas destinés à être utilisés dans des opérations en vrac. Ils offrent flexibilité, séparation des préoccupations et autres avantages, mais les opérations en bloc (sauf la lecture en bloc) n'en font pas partie.

Une autre option consiste à utiliser SqlBulkTools disponible auprès de Nuget. Il est très facile à utiliser et possède des fonctionnalités puissantes.

Exemple:

var bulk = new BulkOperations();
var books = GetBooks();

using (TransactionScope trans = new TransactionScope())
{
    using (SqlConnection conn = new SqlConnection(ConfigurationManager
    .ConnectionStrings["SqlBulkToolsTest"].ConnectionString))
    {
        bulk.Setup<Book>()
            .ForCollection(books)
            .WithTable("Books") 
            .AddAllColumns()
            .BulkInsert()
            .Commit(conn);
    }

    trans.Complete();
}

Voir la documentation pour plus d'exemples et une utilisation avancée. Avertissement: je suis l'auteur de cette bibliothèque et toutes les opinions sont de mon avis.

Selon ma connaissance , il est no BulkInserten EntityFrameworkaugmenter les performances des inserts énormes.

Dans ce scénario , vous pouvez aller avec SqlBulkCopy dans ADO.netpour résoudre votre problème

Avez-vous déjà essayé d'insérer un travail ou une tâche en arrière-plan?

Dans mon cas, j'insère 7760 registres, répartis dans 182 tables différentes avec des relations de clé étrangère (par NavigationProperties).

Sans la tâche, cela a pris 2 minutes et demie. Dans une tâche ( Task.Factory.StartNew(...)), cela a pris 15 secondes.

Je ne fais SaveChanges()qu'après avoir ajouté toutes les entités au contexte. (pour assurer l'intégrité des données)

Toutes les solutions écrites ici n'aident pas car lorsque vous effectuez SaveChanges (), les instructions d'insertion sont envoyées à la base de données une par une, c'est ainsi que fonctionne Entity.

Et si votre trajet vers la base de données et retour est de 50 ms par exemple, le temps nécessaire pour l'insertion est le nombre d'enregistrements x 50 ms.

Vous devez utiliser BulkInsert, voici le lien: https://efbulkinsert.codeplex.com/

J'ai obtenu un temps d'insertion réduit de 5-6 minutes à 10-12 secondes en l'utilisant.

Vous pouvez utiliser la bibliothèque de packages en vrac . La version Bulk Insert 1.0.0 est utilisée dans les projets ayant un framework Entity> = 6.0.0.

Plus de description peut être trouvée ici - Code source de Bulkoperation

[NOUVELLE SOLUTION POUR POSTGRESQL] Hé, je sais que c'est un article assez ancien, mais j'ai récemment rencontré un problème similaire, mais nous utilisions Postgresql. Je voulais utiliser un bulkinsert efficace, ce qui s'est avéré assez difficile. Je n'ai trouvé aucune bibliothèque gratuite appropriée pour le faire sur cette base de données. Je n'ai trouvé que cette aide: https://bytefish.de/blog/postgresql_bulk_insert/ qui est également sur Nuget. J'ai écrit un petit mappeur, qui mappe automatiquement les propriétés comme Entity Framework:

public static PostgreSQLCopyHelper<T> CreateHelper<T>(string schemaName, string tableName)
        {
            var helper = new PostgreSQLCopyHelper<T>("dbo", "\"" + tableName + "\"");
            var properties = typeof(T).GetProperties();
            foreach(var prop in properties)
            {
                var type = prop.PropertyType;
                if (Attribute.IsDefined(prop, typeof(KeyAttribute)) || Attribute.IsDefined(prop, typeof(ForeignKeyAttribute)))
                    continue;
                switch (type)
                {
                    case Type intType when intType == typeof(int) || intType == typeof(int?):
                        {
                            helper = helper.MapInteger("\"" + prop.Name + "\"",  x => (int?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type stringType when stringType == typeof(string):
                        {
                            helper = helper.MapText("\"" + prop.Name + "\"", x => (string)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type dateType when dateType == typeof(DateTime) || dateType == typeof(DateTime?):
                        {
                            helper = helper.MapTimeStamp("\"" + prop.Name + "\"", x => (DateTime?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type decimalType when decimalType == typeof(decimal) || decimalType == typeof(decimal?):
                        {
                            helper = helper.MapMoney("\"" + prop.Name + "\"", x => (decimal?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type doubleType when doubleType == typeof(double) || doubleType == typeof(double?):
                        {
                            helper = helper.MapDouble("\"" + prop.Name + "\"", x => (double?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type floatType when floatType == typeof(float) || floatType == typeof(float?):
                        {
                            helper = helper.MapReal("\"" + prop.Name + "\"", x => (float?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type guidType when guidType == typeof(Guid):
                        {
                            helper = helper.MapUUID("\"" + prop.Name + "\"", x => (Guid)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                }
            }
            return helper;
        }

Je l'utilise de la manière suivante (j'avais une entité nommée Entreprise):

var undertakingHelper = BulkMapper.CreateHelper<Model.Undertaking>("dbo", nameof(Model.Undertaking));
undertakingHelper.SaveAll(transaction.UnderlyingTransaction.Connection as Npgsql.NpgsqlConnection, undertakingsToAdd));

J'ai montré un exemple de transaction, mais cela peut aussi être fait avec une connexion normale récupérée du contexte. enterprisesToAdd est dénombrable des enregistrements d'entité normaux, que je veux insérer en masse dans DB.

Cette solution, à laquelle je suis arrivé après quelques heures de recherche et d'essais, est comme vous pouvez vous attendre beaucoup plus rapide et enfin facile à utiliser et gratuite! Je vous conseille vraiment d'utiliser cette solution, non seulement pour les raisons mentionnées ci-dessus, mais aussi parce que c'est la seule avec laquelle je n'ai eu aucun problème avec Postgresql lui-même, de nombreuses autres solutions fonctionnent parfaitement, par exemple avec SqlServer.

Le secret est d'insérer dans une table de transfert vierge identique. Les inserts s'éclaircissent rapidement. Exécutez ensuite un seul insert à partir de cela dans votre grande table principale. Tronquez ensuite la table intermédiaire prête pour le prochain lot.

c'est à dire.

insert into some_staging_table using Entity Framework.

-- Single insert into main table (this could be a tiny stored proc call)
insert into some_main_already_large_table (columns...)
   select (columns...) from some_staging_table
truncate table some_staging_table

Mais, pour plus de (+4000) insertions, je recommande d'utiliser la procédure stockée. joint le temps écoulé. Je l'ai inséré 11,788 lignes en 20 "

c'est le code

 public void InsertDataBase(MyEntity entity)
    {
        repository.Database.ExecuteSqlCommand("sp_mystored " +
                "@param1, @param2"
                 new SqlParameter("@param1", entity.property1),
                 new SqlParameter("@param2", entity.property2));
    }

Utilisez une procédure stockée qui prend les données d'entrée sous forme de XML pour insérer des données.

À partir de votre code c #, insérez des données au format xml.

par exemple en c #, la syntaxe serait comme ceci:

object id_application = db.ExecuteScalar("procSaveApplication", xml)

Utilisez cette technique pour augmenter la vitesse d'insertion des enregistrements dans Entity Framework. Ici, j'utilise une procédure stockée simple pour insérer les enregistrements. Et pour exécuter cette procédure stockée, j'utilise la méthode .FromSql () d'Entity Framework qui exécute le SQL brut.

Le code de procédure stockée:

CREATE PROCEDURE TestProc
@FirstParam VARCHAR(50),
@SecondParam VARCHAR(50)

AS
  Insert into SomeTable(Name, Address) values(@FirstParam, @SecondParam) 
GO

Ensuite, parcourez tous vos 4000 enregistrements et ajoutez le code Entity Framework qui exécute le stocké

la procédure se répète toutes les 100 boucles.

Pour cela, je crée une requête de chaîne pour exécuter cette procédure, continuez à lui ajouter tous les enregistrements.

Vérifiez ensuite que la boucle s'exécute par multiples de 100 et, dans ce cas, exécutez-la en utilisant .FromSql().

Donc, pour 4000 enregistrements, je n'ai à exécuter la procédure que pour 4000/100 = 40 fois .

Vérifiez le code ci-dessous:

string execQuery = "";
var context = new MyContext();
for (int i = 0; i < 4000; i++)
{
    execQuery += "EXEC TestProc @FirstParam = 'First'" + i + "'', @SecondParam = 'Second'" + i + "''";

    if (i % 100 == 0)
    {
        context.Student.FromSql(execQuery);
        execQuery = "";
    }
}