Szukam najszybszego sposobu wstawienia do Entity Framework.

Pytam o to ze względu na scenariusz, w którym masz aktywny TransactionScope, a wstawienie jest ogromne (4000+). Może to potencjalnie trwać dłużej niż 10 minut (domyślny limit czasu transakcji), co doprowadzi do niekompletnej transakcji.

Do Twojej uwagi w komentarzach do twojego pytania:

„... Zapisywanie zmian ( dla każdego rekordu ) ...”

To najgorsze, co możesz zrobić! Wezwanie SaveChanges()do każdego rekordu spowalnia bardzo duże wkładki luzem. Zrobiłbym kilka prostych testów, które prawdopodobnie poprawią wydajność:

• Zadzwoń SaveChanges()raz po WSZYSTKICH rekordach.
• Zadzwoń SaveChanges()po na przykład 100 rekordów.
• Przywołaj SaveChanges()na przykład 100 rekordów i usuń kontekst i utwórz nowy.
• Wyłącz wykrywanie zmian

W przypadku wkładek luzem pracuję i eksperymentuję z takim wzorem:

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

Mam program testowy, który wstawia 560 000 jednostek (9 właściwości skalarnych, brak właściwości nawigacyjnych) do DB. Z tym kodem działa w mniej niż 3 minuty.

Dla wykonania ważne jest, aby wywoływać SaveChanges()po „wielu” rekordach („wielu” około 100 lub 1000). Poprawia także wydajność, aby pozbyć się kontekstu po SaveChanges i utworzyć nowy. To usuwa kontekst ze wszystkich entites, SaveChangesnie robi tego, byty są nadal dołączone do kontekstu w stanie Unchanged. Rosnące rozmiary dołączonych elementów w kontekście spowalniają wstawianie krok po kroku. Pomocne jest więc wyczyszczenie go po pewnym czasie.

Oto kilka pomiarów dla moich 560000 podmiotów:

• commitCount = 1, createateContext = false: many hours (To jest twoja obecna procedura)
• commitCount = 100, createateContext = false: ponad 20 minut
• commitCount = 1000, createateContext = false: 242 sec
• commitCount = 10000, createateContext = false: 202 sec
• commitCount = 100000, createateContext = false: 199 sec
• commitCount = 1000000, createateContext = false: wyjątek braku pamięci
• commitCount = 1, createateContext = true: ponad 10 minut
• commitCount = 10, createateContext = true: 241 sec
• commitCount = 100, createateContext = true: 164 sec
• commitCount = 1000, createateContext = true: 191 sec

Zachowanie w pierwszym powyższym teście polega na tym, że wydajność jest bardzo nieliniowa i z czasem bardzo spada. („Wiele godzin” to oszacowanie, nigdy nie ukończyłem tego testu, po 20 minutach zatrzymałem się na 50 000 jednostek). To nieliniowe zachowanie nie jest tak znaczące we wszystkich innych testach.

Ta kombinacja wystarczająco dobrze zwiększa prędkość.

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

Najszybszym sposobem byłoby użycie rozszerzenia wkładki luzem , które opracowałem

Uwaga: jest to produkt komercyjny, nie bezpłatnie

Wykorzystuje SqlBulkCopy i niestandardowy moduł danych, aby uzyskać maksymalną wydajność. W rezultacie jest ponad 20 razy szybszy niż zwykłe wstawianie lub AddRange

użycie jest niezwykle proste

context.BulkInsert(hugeAmountOfEntities);

Powinieneś spojrzeć na użycie System.Data.SqlClient.SqlBulkCopydo tego. Oto dokumentacja i oczywiście jest wiele samouczków online.

Przykro mi, wiem, że szukałeś prostej odpowiedzi, aby EF mógł zrobić to, co chcesz, ale operacje masowe nie są tak naprawdę przeznaczone do ORM.

Zgadzam się z Adamem Rackisem. SqlBulkCopyto najszybszy sposób przesyłania zbiorczych rekordów z jednego źródła danych do drugiego. Użyłem tego do skopiowania rekordów 20 000 i zajęło to mniej niż 3 sekundy. Spójrz na poniższy przykład.

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

    }
}

Poleciłbym ten artykuł, w jaki sposób robić wkładki zbiorcze za pomocą EF.

Entity Framework i powolne WSTAWKI luzem

Bada te obszary i porównuje występy:

1. Domyślny EF (57 minut, aby zakończyć dodawanie 30 000 rekordów)
2. Zastąpienie kodem ADO.NET (25 sekund dla tych samych 30 000)
3. Nadmuchanie kontekstu - Zachowaj mały aktywny wykres kontekstu, używając nowego kontekstu dla każdej jednostki pracy (te same 30 000 wstawek zajmuje 33 sekundy)
4. Duże listy - wyłącz AutoDetectChangesEnabled (skraca czas do około 20 sekund)
5. Dozowanie (do 16 sekund)
6. DbTable.AddRange () - (wydajność mieści się w zakresie 12)

jak nigdy tu nie wspomniano, chcę polecić EFCore.BulkExtensions tutaj

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

Zbadałem odpowiedź Slaumy (co jest niesamowite, dzięki za pomysłowca) i zmniejszałem wielkość partii, aż osiągną optymalną prędkość. Patrząc na wyniki Slauma:

• commitCount = 1, createateContext = true: ponad 10 minut
• commitCount = 10, createateContext = true: 241 sec
• commitCount = 100, createateContext = true: 164 sec
• commitCount = 1000, createateContext = true: 191 sec

Widoczne jest zwiększenie prędkości przy przechodzeniu od 1 do 10 i od 10 do 100, ale ze 100 do 1000 prędkość wstawiania ponownie spada.

Więc skupiłem się na tym, co się dzieje, gdy zmniejszasz wielkość partii do wartości między 10 a 100, a oto moje wyniki (używam innej zawartości wiersza, więc moje czasy mają inną wartość):

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

W oparciu o moje wyniki, rzeczywiste optimum wynosi około 30 dla wielkości partii. Jest mniej niż 10 i 100. Problem w tym, że nie mam pojęcia, dlaczego 30 jest optymalne, ani nie mogłem znaleźć żadnego logicznego wyjaśnienia tego.

Jak powiedzieli inni, SqlBulkCopy to sposób na zrobienie tego, jeśli chcesz naprawdę dobrej wydajności wstawiania.

Jest to trochę kłopotliwe we wdrożeniu, ale istnieją biblioteki, które mogą ci w tym pomóc. Jest ich kilka, ale tym razem bezwstydnie podłączę własną bibliotekę: https://github.com/MikaelEliasson/EntityFramework.Utilities#batch-insert-entities

Jedyny potrzebny kod to:

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

Ile to jest szybsze? Bardzo trudno powiedzieć, ponieważ zależy to od wielu czynników, wydajności komputera, sieci, wielkości obiektu itp. Testy wydajności, które przeprowadziłem, sugerują, że 25 000 jednostek można wstawić około 10s standardowego sposobu na localhost JEŻELI zoptymalizujesz konfigurację EF, np. wspomniane w innych odpowiedziach. Z EFUtilities, które zajmuje około 300ms. Jeszcze bardziej interesujące jest to, że dzięki tej metodzie zaoszczędziłem około 3 milionów jednostek w ciągu 15 sekund, średnio około 200 000 jednostek na sekundę.

Jedynym problemem jest oczywiście konieczność wstawienia powiązanych danych. Można to zrobić skutecznie na serwerze SQL za pomocą powyższej metody, ale wymaga strategii generowania Id, która pozwala generować identyfikatory w kodzie aplikacji dla nadrzędnego, dzięki czemu można ustawić klucze obce. Można to zrobić za pomocą identyfikatorów GUID lub czegoś takiego jak generowanie identyfikatora HiLo.

Dispose()Kontekst stwarza problemy, jeśli elementy Add()polegają na innych wstępnie załadowanych elementach (np. właściwościach nawigacji) w kontekście

Używam podobnej koncepcji, aby mój kontekst był mały, aby osiągnąć taką samą wydajność

Ale zamiast Dispose()kontekstu i odtworzyć, po prostu odłączam jednostki, które już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;
} }

owiń go za pomocą try catch, a TrasactionScope()jeśli nie potrzebujesz, nie pokazuj go tutaj w celu utrzymania kodu w czystości

Wiem, że to bardzo stare pytanie, ale jeden facet powiedział, że opracował metodę rozszerzenia do użycia wstawiania zbiorczego z EF, a kiedy sprawdziłem, odkryłem, że biblioteka kosztuje dziś 599 USD (dla jednego programisty). Może ma to sens dla całej biblioteki, jednak dla samej wstawki zbiorczej jest to zbyt wiele.

Oto bardzo prosta metoda rozszerzenia, którą stworzyłem. Najpierw używam tego w parze z bazą danych (najpierw nie testuj z kodem, ale myślę, że to działa tak samo). Zmień YourEntitiesz nazwą swojego kontekstu:

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

Możesz użyć tego przeciwko dowolnej kolekcji, która dziedziczy IEnumerable, w następujący sposób:

await context.BulkInsertAllAsync(items);

Spróbuj użyć procedury składowanej , która otrzyma XML danych, które chcesz wstawić.

Zrobiłem ogólne rozszerzenie powyższego przykładu @Slauma;

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

Stosowanie:

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

Szukam najszybszego sposobu wstawienia do Entity Framework

Dostępne są biblioteki innych firm obsługujące wstawianie luzem:

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

Zobacz: Biblioteka Entity Framework Bulk Insert

Zachowaj ostrożność przy wyborze biblioteki wstawiania zbiorczego. Tylko rozszerzenia Entity Framework obsługują wszelkiego rodzaju powiązania i dziedziczenia i jest to jedyne obsługiwane.

Oświadczenie : Jestem właścicielem rozszerzeń Entity Framework

Ta biblioteka pozwala na wykonywanie wszystkich operacji masowych potrzebnych w Twoich scenariuszach:

• Bulk SaveChanges
• Wstaw luzem
• Usuń zbiorczo
• Aktualizacja zbiorcza
• Łączenie zbiorcze

Przykład

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

Użyj 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;
}

Jednym z najszybszych sposobów zapisania listy jest zastosowanie następującego kodu

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

AutoDetectChangesEnabled = false

Add, AddRange i SaveChanges: Nie wykrywa zmian.

ValidateOnSaveEnabled = false;

Nie wykrywa modułu do śledzenia zmian

Musisz dodać nuget

Install-Package Z.EntityFramework.Extensions

Teraz możesz użyć następującego kodu

var context = new MyContext();

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

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

SqlBulkCopy jest bardzo szybki

To jest moja realizacja:

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

[Aktualizacja 2019] EF Core 3.1

Zgodnie z tym, co powiedziano powyżej, wyłączenie AutoDetectChangesEnabled w EF Core działało idealnie: czas wstawienia został podzielony przez 100 (od wielu minut do kilku sekund, 10 000 rekordów z relacjami między tabelami)

Zaktualizowany kod to:

  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

Oto porównanie wydajności między użyciem Entity Framework a użyciem klasy SqlBulkCopy na realistycznym przykładzie: Jak luzem wstawiać złożone obiekty do bazy danych SQL Server

Jak już podkreślili inni, ORM nie są przeznaczone do użycia w operacjach masowych. Oferują elastyczność, rozdzielenie problemów i inne korzyści, ale operacje masowe (z wyjątkiem masowego odczytu) nie są jedną z nich.

Inną opcją jest użycie SqlBulkTools dostępnych w Nuget. Jest bardzo łatwy w użyciu i ma kilka zaawansowanych funkcji.

Przykład:

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

Zobacz dokumentację, aby uzyskać więcej przykładów i zaawansowanych zastosowań. Oświadczenie: Jestem autorem tej biblioteki i wszelkie poglądy są moim zdaniem.

Zgodnie z moją wiedzą jest no BulkInsertw EntityFrameworkcelu zwiększenia wydajności ogromnych wkładek.

W tym scenariuszu możesz przejść do SqlBulkCopy w, ADO.netaby rozwiązać problem

Czy próbowałeś kiedyś wstawić pracownika lub zadanie w tle?

W moim przypadku im wstawiam 7760 rejestrów, rozproszonych w 182 różnych tabelach z relacjami klucza obcego (według NavigationProperties).

Bez zadania zajęło to 2 i pół minuty. W ramach zadania ( Task.Factory.StartNew(...)) zajęło to 15 sekund.

Robię tylko SaveChanges()po dodaniu wszystkich bytów do kontekstu. (w celu zapewnienia integralności danych)

Wszystkie opisane tutaj rozwiązania nie pomagają, ponieważ kiedy wykonujesz SaveChanges (), instrukcje insert są wysyłane do bazy danych jedna po drugiej, tak działa Entity.

A jeśli na przykład podróż do bazy danych iz powrotem trwa 50 ms, czas potrzebny na wstawienie to liczba rekordów x 50 ms.

Musisz użyć BulkInsert, oto link: https://efbulkinsert.codeplex.com/

Dzięki temu czas wstawiania został skrócony z 5-6 minut do 10-12 sekund.

Możesz użyć biblioteki pakietów Bulk . Wersja Bulk Insert 1.0.0 jest używana w projektach o strukturze Entity> = 6.0.0.

Więcej opisu można znaleźć tutaj - kod źródłowy operacji masowej

[NOWE ROZWIĄZANIE DLA POSTGRESQL] Hej, wiem, że to dość stary post, ale ostatnio miałem podobny problem, ale korzystaliśmy z Postgresql. Chciałem zastosować skuteczny bulkinsert, co okazało się dość trudne. Nie znalazłem żadnej odpowiedniej darmowej biblioteki, aby to zrobić na tym DB. Znalazłem tylko tego pomocnika: https://bytefish.de/blog/postgresql_bulk_insert/, który jest również dostępny w Nuget. Napisałem małego mapera, który automatycznie mapuje właściwości w sposób 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;
        }

Używam go w następujący sposób (miałem podmiot o nazwie Zobowiązanie):

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

Pokazałem przykład transakcji, ale można to również zrobić przy normalnym połączeniu pobranym z kontekstu. enterpriseToAdd jest wyliczalny dla normalnych rekordów encji, które chcę zbiorczo wstawić do DB.

To rozwiązanie, do którego mam po kilku godzinach badań i prób, jest, jak można się spodziewać, znacznie szybsze i wreszcie łatwe w użyciu i darmowe! Naprawdę radzę korzystać z tego rozwiązania, nie tylko z wyżej wymienionych powodów, ale także dlatego, że jest to jedyne, z którym nie miałem problemów z samym Postgresqlem, wiele innych rozwiązań działa bezbłędnie, na przykład z SqlServer.

Sekret polega na wstawieniu do identycznej pustej tabeli pomostowej. Wkładki błyskawicznie się rozjaśniają. Następnie uruchom jedną wstawkę z tego do głównego dużego stołu. Następnie obetnij stół pomostowy gotowy do następnej partii.

to znaczy.

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

Ale dla więcej niż (+4000) wkładek zalecam stosowanie procedury składowanej. dołączony czas, który upłynął. Wstawiłem 11,788 wierszy w 20 "

to jest kod

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

Użyj procedury składowanej, która pobiera dane wejściowe w postaci xml.

Z kodu c # pass wstaw dane jako xml.

np. w c #, składnia wyglądałaby tak:

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

Użyj tej techniki, aby zwiększyć szybkość wstawiania rekordów w Entity Framework. Tutaj używam prostej procedury składowanej, aby wstawić rekordy. I do wykonania tej procedury składowanej używam metody .FromSql () Entity Framework, która wykonuje Raw SQL.

Kod procedury składowanej:

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

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

Następnie przejrzyj wszystkie 4000 rekordów i dodaj kod Entity Framework, który wykonuje zapisany zapis

procedura wykonuje się co 100 pętlę.

W tym celu tworzę zapytanie łańcuchowe w celu wykonania tej procedury, ciągle dołączam do niego każdy zestaw rekordów.

Następnie sprawdź, czy pętla działa w wielokrotnościach 100 i w takim przypadku uruchom ją za pomocą .FromSql().

Tak więc dla 4000 rekordów muszę wykonać procedurę tylko 4000/100 = 40 razy .

Sprawdź poniższy kod:

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