Sto cercando il modo più veloce per inserire in Entity Framework.

Lo sto chiedendo a causa dello scenario in cui hai un TransactionScope attivo e l'inserimento è enorme (4000+). Può durare potenzialmente più di 10 minuti (timeout predefinito delle transazioni) e ciò comporterà una transazione incompleta.

Alla tua osservazione nei commenti alla tua domanda:

"... SavingChanges ( per ogni record ) ..."

Questa è la cosa peggiore che puoi fare! La chiamata SaveChanges()per ogni record rallenta notevolmente gli inserti di massa. Farei alcuni semplici test che molto probabilmente miglioreranno le prestazioni:

• Chiama SaveChanges()una volta dopo TUTTI i record.
• Chiamare SaveChanges()dopo ad esempio 100 record.
• Chiamare SaveChanges()dopo ad esempio 100 record e disporre il contesto e crearne uno nuovo.
• Disabilita il rilevamento delle modifiche

Per inserti di massa sto lavorando e sperimentando un modello come questo:

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

Ho un programma di test che inserisce 560.000 entità (9 proprietà scalari, nessuna proprietà di navigazione) nel DB. Con questo codice funziona in meno di 3 minuti.

Per le prestazioni è importante chiamare SaveChanges()dopo "molti" record ("molti" circa 100 o 1000). Migliora anche le prestazioni per disporre il contesto dopo SaveChanges e crearne uno nuovo. Questo cancella il contesto da tutte le entità, SaveChangesnon lo fa, le entità sono ancora attaccate al contesto nello stato Unchanged. È la dimensione crescente delle entità collegate nel contesto che rallenta l'inserimento passo dopo passo. Quindi, è utile cancellarlo dopo qualche tempo.

Ecco alcune misure per le mie 560000 entità:

• commitCount = 1 ,reatteContext = false: molte ore (Questa è la procedura corrente)
• commitCount = 100, ricreateContext = false: più di 20 minuti
• commitCount = 1000, ricreateContext = false: 242 sec
• commitCount = 10000, ricreateContext = false: 202 sec
• commitCount = 100000, ricreateContext = false: 199 sec
• commitCount = 1000000 ,reatteContext = false: eccezione di memoria insufficiente
• commitCount = 1, ricreateContext = true: più di 10 minuti
• commitCount = 10, ricreateContext = true: 241 sec
• commitCount = 100, ricreateContext = true: 164 sec
• commitCount = 1000, ricreateContext = true: 191 sec

Il comportamento nel primo test sopra è che le prestazioni sono molto non lineari e diminuiscono estremamente nel tempo. ("Molte ore" è una stima, non ho mai finito questo test, mi sono fermato a 50.000 entità dopo 20 minuti.) Questo comportamento non lineare non è così significativo in tutti gli altri test.

Questa combinazione aumenta la velocità abbastanza bene.

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

Il modo più veloce sarebbe usare l' estensione dell'inserto di massa , che ho sviluppato

nota: questo è un prodotto commerciale, non gratuito

Utilizza SqlBulkCopy e Datareader personalizzato per ottenere le massime prestazioni. Di conseguenza è oltre 20 volte più veloce rispetto all'utilizzo dell'inserto regolare o AddRange

l'utilizzo è estremamente semplice

context.BulkInsert(hugeAmountOfEntities);

Dovresti cercare di usare il System.Data.SqlClient.SqlBulkCopyper questo. Ecco la documentazione e, naturalmente, ci sono molti tutorial online.

Siamo spiacenti, so che stavi cercando una risposta semplice per fare in modo che EF facesse quello che volevi, ma le operazioni in blocco non sono realmente ciò per cui sono destinati gli ORM.

Sono d'accordo con Adam Rackis. SqlBulkCopyè il modo più veloce di trasferire record di massa da un'origine dati a un'altra. Ho usato questo per copiare 20K record e ci sono voluti meno di 3 secondi. Dai un'occhiata all'esempio qui sotto.

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();
        }

    }
}

Consiglierei questo articolo su come eseguire inserti di massa usando EF.

Entity Framework e INSERT lenti alla rinfusa

Esplora queste aree e confronta le prestazioni:

1. EF predefinito (57 minuti per completare l'aggiunta di 30.000 record)
2. Sostituzione con codice ADO.NET (25 secondi per gli stessi 30.000)
3. Contesto gonfio: mantieni piccolo il grafico di contesto attivo utilizzando un nuovo contesto per ogni unità di lavoro (gli stessi 30.000 inserti richiedono 33 secondi)
4. Elenchi di grandi dimensioni: disattiva AutoDetectChangesEnabled (riduce il tempo a circa 20 secondi)
5. Batching (fino a 16 secondi)
6. DbTable.AddRange () - (le prestazioni sono nell'intervallo 12)

come non è mai stato menzionato qui, voglio consigliare EFCore.BulkExtensions qui

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

Ho studiato la risposta di Slauma (che è fantastico, grazie per l'idea uomo) e ho ridotto le dimensioni del lotto fino a raggiungere la velocità ottimale. Guardando i risultati di Slauma:

• commitCount = 1, ricreateContext = true: più di 10 minuti
• commitCount = 10, ricreateContext = true: 241 sec
• commitCount = 100, ricreateContext = true: 164 sec
• commitCount = 1000, ricreateContext = true: 191 sec

È visibile un aumento della velocità quando si passa da 1 a 10 e da 10 a 100, ma da 100 a 1000 la velocità di inserimento diminuisce nuovamente.

Quindi mi sono concentrato su ciò che sta accadendo quando riduci le dimensioni del batch per un valore compreso tra 10 e 100, e qui ci sono i miei risultati (sto usando diversi contenuti di riga, quindi i miei tempi hanno un valore diverso):

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

Sulla base dei miei risultati, l'ottimale effettivo è di circa 30 per la dimensione del lotto. È inferiore sia a 10 che a 100. Il problema è che non ho idea del perché sia ​​ottimale 30, né avrei potuto trovare alcuna spiegazione logica per questo.

Come altri hanno già detto, SqlBulkCopy è il modo di farlo se si desidera ottenere prestazioni di inserimento davvero buone.

È un po 'complicato da implementare ma ci sono librerie che possono aiutarti. Ce ne sono alcuni là fuori, ma stavolta collegherò senza vergogna la mia libreria: https://github.com/MikaelEliasson/EntityFramework.Utilities#batch-insert-entities

L'unico codice di cui hai bisogno è:

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

Quindi quanto è più veloce? Molto difficile da dire perché dipende da tanti fattori, prestazioni del computer, rete, dimensioni degli oggetti, ecc. I test delle prestazioni che ho fatto suggeriscono che 25k entità possono essere inserite a circa 10 secondi nello standard host locale se ottimizzi la tua configurazione EF come menzionato nelle altre risposte. Con EFUtilities che impiega circa 300ms. Ancora più interessante è che ho salvato circa 3 milioni di entità in meno di 15 secondi usando questo metodo, con una media di circa 200k entità al secondo.

L'unico problema è ovvio se è necessario inserire dati ripetuti. Questo può essere fatto efficacemente in SQL Server usando il metodo sopra ma richiede che tu abbia una strategia di generazione di Id che ti consenta di generare ID nel codice app per il genitore in modo da poter impostare le chiavi esterne. Questo può essere fatto usando GUID o qualcosa come la generazione dell'ID HiLo.

Dispose()il contesto crea problemi se le entità su cui si fa Add()affidamento su altre entità precaricate (ad es. proprietà di navigazione) nel contesto

Uso un concetto simile per mantenere piccolo il mio contesto per ottenere le stesse prestazioni

Ma invece del Dispose()contesto e ricreare, semplicemente distacco le entità che già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;
} }

avvolgetelo con try catch e, TrasactionScope()se necessario, non mostratelo qui per mantenere pulito il codice

So che questa è una domanda molto vecchia, ma un ragazzo qui ha detto che ha sviluppato un metodo di estensione per utilizzare l'inserimento di massa con EF, e quando ho controllato, ho scoperto che la libreria costa $ 599 oggi (per uno sviluppatore). Forse ha senso per l'intera libreria, tuttavia solo per l'inserimento di massa questo è troppo.

Ecco un metodo di estensione molto semplice che ho creato. Lo uso prima sull'associazione con il database (non testare prima con il codice, ma penso che funzioni allo stesso modo). Cambia YourEntitiescon il nome del tuo contesto:

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

Puoi usarlo contro qualsiasi raccolta da cui eredita IEnumerable, in questo modo:

await context.BulkInsertAllAsync(items);

Prova a utilizzare una Stored Procedure che otterrà un XML dei dati che desideri inserire.

Ho fatto un'estensione generica dell'esempio di @Slauma sopra;

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

Uso:

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();
    }
}

Sto cercando il modo più veloce per inserire in Entity Framework

Sono disponibili alcune librerie di terze parti che supportano l'inserimento di massa:

• Z.EntityFramework.Extensions ( consigliato )
• EFUtilities
• EntityFramework.BulkInsert

Vedi: Entity Framework Bulk Insert library

Fare attenzione, quando si sceglie una libreria di inserimento di massa. Solo Entity Framework Extensions supporta tutti i tipi di associazioni ed eredità ed è l'unico ancora supportato.

Disclaimer : sono il proprietario di Entity Framework Extensions

Questa libreria ti consente di eseguire tutte le operazioni in blocco necessarie per i tuoi scenari:

• Bulk SaveChanges
• Inserto sfuso
• Elimina in blocco
• Aggiornamento in blocco
• Unione in blocco

Esempio

// 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;
});

Utilizzare 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;
}

Uno dei modi più veloci per salvare un elenco è necessario applicare il seguente codice

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

AutoDetectChangesEnabled = false

Aggiungi, Aggiungi intervallo e Salva modifiche: non rileva le modifiche.

ValidateOnSaveEnabled = false;

Non rileva il tracker modifiche

Devi aggiungere nuget

Install-Package Z.EntityFramework.Extensions

Ora puoi usare il seguente codice

var context = new MyContext();

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

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

SqlBulkCopy è super veloce

Questa è la mia implementazione:

// 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;
        }
    }
}

[Aggiornamento 2019] EF Core 3.1

In seguito a quanto detto sopra, la disabilitazione di AutoDetectChangesEnabled in EF Core ha funzionato perfettamente: il tempo di inserimento è stato diviso per 100 (da molti minuti a pochi secondi, 10k record con relazioni tra tabelle)

Il codice aggiornato è:

  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

Ecco un confronto delle prestazioni tra l'utilizzo di Entity Framework e l'uso della classe SqlBulkCopy su un esempio realistico: Come inserire in blocco oggetti complessi nel database di SQL Server

Come altri hanno già sottolineato, gli ORM non sono pensati per essere utilizzati in operazioni in blocco. Offrono flessibilità, separazione delle preoccupazioni e altri vantaggi, ma le operazioni in blocco (tranne la lettura in blocco) non sono tra queste.

Un'altra opzione è utilizzare SqlBulkTools disponibile da Nuget. È molto facile da usare e ha alcune potenti funzionalità.

Esempio:

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();
}

Vedere la documentazione per ulteriori esempi e utilizzo avanzato. Dichiarazione di non responsabilità: sono l'autore di questa libreria e tutte le opinioni sono a mio avviso.

Come per la mia conoscenza non v'è no BulkInsertin EntityFrameworkper aumentare le prestazioni dei grandi inserti.

In questo scenario si può andare con SqlBulkCopy in ADO.netper risolvere il problema

Hai mai provato a inserire un lavoratore o un'attività in background?

Nel mio caso, sto inserendo 7760 registri, distribuiti in 182 diverse tabelle con relazioni di chiave esterna (di NavigationProperties).

Senza il compito, ci sono voluti 2 minuti e mezzo. All'interno di un'attività ( Task.Factory.StartNew(...)), ci sono voluti 15 secondi.

Sto facendo solo SaveChanges()dopo aver aggiunto tutte le entità al contesto. (per garantire l'integrità dei dati)

Tutte le soluzioni scritte qui non aiutano perché quando si esegue SaveChanges (), le istruzioni di inserimento vengono inviate al database una per una, ecco come funziona Entity.

E se il tuo viaggio nel database e ritorno è di 50 ms, ad esempio, il tempo necessario per l'inserimento è il numero di record x 50 ms.

Devi usare BulkInsert, ecco il link: https://efbulkinsert.codeplex.com/

Ho usato il tempo di inserimento ridotto da 5-6 minuti a 10-12 secondi.

È possibile utilizzare la libreria di pacchetti di massa . La versione Bulk Insert 1.0.0 viene utilizzata nei progetti con Entity framework> = 6.0.0.

Ulteriori informazioni sono disponibili qui - Codice sorgente di operazione in blocco

[NUOVA SOLUZIONE PER POSTGRESQL] Ehi, so che è un post piuttosto vecchio, ma di recente ho riscontrato un problema simile, ma stavamo usando Postgresql. Volevo usare un efficace bulkinsert, che si è rivelato piuttosto difficile. Non ho trovato alcuna libreria gratuita adeguata per farlo su questo DB. Ho trovato solo questo aiuto: https://bytefish.de/blog/postgresql_bulk_insert/ che è anche su Nuget. Ho scritto un piccolo mappatore, che ha mappato automaticamente le proprietà nel modo in cui 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;
        }

Lo uso nel modo seguente (avevo un'entità chiamata Undertaking):

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

Ho mostrato un esempio con la transazione, ma può anche essere fatto con una normale connessione recuperata dal contesto. enterprisesToAdd è un elenco di normali record di entità, che voglio inserire in blocco nel DB.

Questa soluzione, che ho dopo poche ore di ricerca e di prova, è come ci si potrebbe aspettare molto più velocemente e finalmente facile da usare e gratuita! Ti consiglio davvero di utilizzare questa soluzione, non solo per i motivi sopra menzionati, ma anche perché è l'unico con cui non ho avuto problemi con Postgresql stesso, molte altre soluzioni funzionano perfettamente, ad esempio con SqlServer.

Il segreto è inserire in una tabella di stadiazione vuota identica. Gli inserti si schiariscono rapidamente. Quindi esegui un singolo inserto da quello nella tabella principale principale. Quindi troncare la tabella di gestione temporanea pronta per il batch successivo.

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

Ma, per più di (+4000) inserti, consiglio di usare la procedura memorizzata. allegato il tempo trascorso. L'ho inserito 11.788 righe in 20 "

questo è il codice

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

Utilizzare la procedura memorizzata che accetta i dati di input in formato XML per inserire i dati.

Dal tuo codice c # passa inserisci i dati come xml.

ad es. in c #, la sintassi sarebbe così:

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

Utilizzare questa tecnica per aumentare la velocità di inserimento dei record in Entity Framework. Qui utilizzo una semplice procedura memorizzata per inserire i record. E per eseguire questa procedura memorizzata uso il metodo .FromSql () di Entity Framework che esegue Raw SQL.

Il codice della procedura memorizzata:

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

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

Quindi, scorrere tutti i 4000 record e aggiungere il codice Entity Framework che esegue l'archiviazione

la procedura continua ogni 100 ° ciclo.

Per questo creo una query di stringa per eseguire questa procedura, continuando ad aggiungervi ogni set di record.

Quindi controlla che il ciclo sia in esecuzione nei multipli di 100 e in quel caso eseguilo usando .FromSql().

Quindi per 4000 record devo eseguire la procedura solo per 4000/100 = 40 volte .

Controlla il codice qui sotto:

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 = "";
    }
}