Saya mencari cara tercepat untuk memasukkan ke dalam Kerangka Entitas.

Saya bertanya ini karena skenario di mana Anda memiliki TransactionScope aktif dan penyisipan sangat besar (4000+). Ini berpotensi bertahan lebih dari 10 menit (batas waktu transaksi default), dan ini akan menyebabkan transaksi tidak lengkap.

Untuk komentar Anda di komentar untuk pertanyaan Anda:

"... Menyimpan Perubahan ( untuk setiap catatan ) ..."

Itu hal terburuk yang bisa Anda lakukan! Memanggil SaveChanges()untuk setiap record memperlambat insert massal sangat turun Saya akan melakukan beberapa tes sederhana yang kemungkinan besar akan meningkatkan kinerja:

• Panggil SaveChanges()sekali setelah SEMUA catatan.
• Panggil SaveChanges()setelah misalnya 100 catatan.
• Panggil SaveChanges()setelah misalnya 100 catatan dan buang konteks dan buat yang baru.
• Nonaktifkan deteksi perubahan

Untuk sisipan massal, saya bekerja dan bereksperimen dengan pola seperti ini:

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

Saya memiliki program pengujian yang memasukkan 560.000 entitas (9 properti skalar, tanpa properti navigasi) ke dalam DB. Dengan kode ini berfungsi kurang dari 3 menit.

Untuk kinerja, penting untuk memanggil SaveChanges()setelah "banyak" catatan ("banyak" sekitar 100 atau 1000). Ini juga meningkatkan kinerja untuk membuang konteks setelah SaveChanges dan membuat yang baru. Ini membersihkan konteks dari semua entites, SaveChangestidak melakukan itu, entitas masih melekat pada konteks di negara Unchanged. Ini adalah ukuran pertumbuhan entitas terlampir dalam konteks yang memperlambat penyisipan langkah demi langkah. Jadi, sangat membantu untuk menghapusnya setelah beberapa waktu.

Berikut adalah beberapa pengukuran untuk entitas 560000 saya:

• commitCount = 1, createateContext = false: berjam-jam (Itulah prosedur Anda saat ini)
• commitCount = 100, createateContext = false: lebih dari 20 menit
• commitCount = 1000, createateContext = false: 242 dtk
• commitCount = 10000, createateContext = false: 202 dtk
• commitCount = 100000, createateContext = false: 199 dtk
• commitCount = 1000000, reinateContext = false: kehabisan memori
• commitCount = 1, createateContext = true: lebih dari 10 menit
• commitCount = 10, createateContext = true: 241 dtk
• commitCount = 100, createateContext = true: 164 dtk
• commitCount = 1000, createateContext = true: 191 dtk

Perilaku dalam tes pertama di atas adalah bahwa kinerjanya sangat non-linear dan menurun sangat dari waktu ke waktu. ("Banyak jam" adalah perkiraan, saya tidak pernah menyelesaikan tes ini, saya berhenti di 50.000 entitas setelah 20 menit.) Perilaku non-linear ini tidak begitu signifikan dalam semua tes lainnya.

Kombinasi ini meningkatkan kecepatan dengan cukup baik.

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

Cara tercepat akan menggunakan ekstensi insert massal , yang saya kembangkan

Catatan: ini adalah produk komersial, tidak gratis

Ia menggunakan SqlBulkCopy dan datareader khusus untuk mendapatkan kinerja maksimal. Akibatnya lebih dari 20 kali lebih cepat daripada menggunakan insert biasa atau AddRange

penggunaannya sangat sederhana

context.BulkInsert(hugeAmountOfEntities);

Anda harus melihat menggunakan System.Data.SqlClient.SqlBulkCopyini. Berikut dokumentasinya , dan tentu saja ada banyak tutorial online.

Maaf, saya tahu Anda sedang mencari jawaban sederhana untuk membuat EF melakukan apa yang Anda inginkan, tetapi operasi massal tidak benar-benar dimaksudkan untuk ORM.

Saya setuju dengan Adam Rackis. SqlBulkCopyadalah cara tercepat untuk mentransfer catatan massal dari satu sumber data ke yang lain. Saya menggunakan ini untuk menyalin catatan 20K dan butuh waktu kurang dari 3 detik. Lihat contoh di bawah ini.

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

    }
}

Saya akan merekomendasikan artikel ini tentang cara melakukan sisipan massal menggunakan EF.

Kerangka Entitas dan MASUK massal lambat

Dia mengeksplorasi bidang-bidang ini dan membandingkan kinerja:

1. EF default (57 menit untuk menyelesaikan penambahan 30.000 catatan)
2. Mengganti dengan ADO.NET Code (25 detik untuk 30.000 yang sama)
3. Context Bloat- Menyimpan Grafik Konteks aktif kecil dengan menggunakan konteks baru untuk setiap Unit Kerja (30.000 sisipan yang sama membutuhkan 33 detik)
4. Daftar Besar - Matikan AutoDetectChangesEnabled (membawa waktu ke sekitar 20 detik)
5. Batching (hingga 16 detik)
6. DbTable.AddRange () - (kinerja dalam kisaran 12)

karena tidak pernah disebutkan di sini saya ingin recomment EFCore.BulkExtensions di sini

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

Saya telah menyelidiki jawaban Slauma (yang luar biasa, terima kasih untuk idenya), dan saya telah mengurangi ukuran bets sampai saya mencapai kecepatan optimal. Melihat hasil Slauma:

• commitCount = 1, createateContext = true: lebih dari 10 menit
• commitCount = 10, createateContext = true: 241 dtk
• commitCount = 100, createateContext = true: 164 dtk
• commitCount = 1000, createateContext = true: 191 dtk

Terlihat bahwa ada peningkatan kecepatan ketika bergerak dari 1 ke 10, dan dari 10 ke 100, tetapi dari 100 hingga 1000 kecepatan memasukkan jatuh lagi.

Jadi saya fokus pada apa yang terjadi ketika Anda mengurangi ukuran bets menjadi nilai di antara 10 dan 100, dan inilah hasil saya (saya menggunakan konten baris yang berbeda, jadi waktu saya nilainya berbeda):

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

Berdasarkan hasil saya, sebenarnya optimal adalah sekitar nilai 30 untuk ukuran batch. Ini kurang dari 10 dan 100. Masalahnya adalah, saya tidak tahu mengapa 30 optimal, saya juga tidak bisa menemukan penjelasan logis untuk itu.

Seperti yang orang lain katakan, SqlBulkCopy adalah cara untuk melakukannya jika Anda ingin kinerja insert yang sangat bagus.

Agak sulit untuk diimplementasikan tetapi ada perpustakaan yang dapat membantu Anda. Ada beberapa di luar sana tapi saya akan tanpa malu mencabut perpustakaan saya sendiri saat ini: https://github.com/MikaelEliasson/EntityFramework.Utilities#batch-insert-entities

Satu-satunya kode yang Anda perlukan adalah:

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

Jadi seberapa cepat itu? Sangat sulit untuk mengatakan karena itu tergantung pada banyak faktor, kinerja komputer, jaringan, ukuran objek dll. Tes kinerja yang saya buat menunjukkan 25k entitas dapat dimasukkan pada sekitar 10-an dengan cara standar di host lokal JIKA Anda mengoptimalkan konfigurasi EF seperti disebutkan dalam jawaban lain. Dengan EFUtilities yang membutuhkan waktu sekitar 300ms. Yang lebih menarik adalah bahwa saya telah menyelamatkan sekitar 3 juta entitas dalam waktu kurang dari 15 detik menggunakan metode ini, rata-rata sekitar 200k entitas per detik.

Satu masalah tentu saja jika Anda perlu memasukkan data yang dirilis. Ini dapat dilakukan secara efisien ke dalam sql server menggunakan metode di atas tetapi mengharuskan Anda untuk memiliki strategi pembuatan Id yang memungkinkan Anda menghasilkan id di kode aplikasi untuk induk sehingga Anda dapat mengatur kunci asing. Ini dapat dilakukan dengan menggunakan GUID atau sesuatu seperti pembuatan HiLo id.

Dispose()konteks membuat masalah jika entitas yang Anda Add()andalkan pada entitas yang dimuat sebelumnya (misalnya properti navigasi) dalam konteks

Saya menggunakan konsep serupa untuk menjaga konteks saya kecil untuk mencapai kinerja yang sama

Tetapi alih-alih Dispose()konteksnya dan menciptakan kembali, saya cukup melepaskan entitas yang sudahSaveChanges()

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

bungkus dengan try catch dan TrasactionScope()jika perlu, jangan perlihatkan di sini untuk menjaga kode tetap bersih

Saya tahu ini adalah pertanyaan yang sangat lama, tetapi seorang pria di sini mengatakan bahwa mengembangkan metode ekstensi untuk menggunakan penyisipan massal dengan EF, dan ketika saya memeriksa, saya menemukan bahwa biaya perpustakaan $ 599 hari ini (untuk satu pengembang). Mungkin masuk akal untuk seluruh perpustakaan, namun untuk memasukkan sebagian besar ini terlalu banyak.

Berikut adalah metode ekstensi yang sangat sederhana yang saya buat. Saya menggunakannya berpasangan dengan database terlebih dahulu (jangan diuji dengan kode terlebih dahulu, tapi saya pikir itu berfungsi sama). Ubah YourEntitiesdengan nama konteks Anda:

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

Anda dapat menggunakannya untuk koleksi apa pun yang mewarisi IEnumerable, seperti itu:

await context.BulkInsertAllAsync(items);

Coba gunakan a Prosedur Tersimpan yang akan mendapatkan XML dari data yang ingin Anda masukkan.

Saya telah membuat ekstensi generik dari contoh @Slauma di atas;

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

Pemakaian:

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

Saya mencari cara tercepat untuk memasukkan ke dalam Kerangka Entitas

Ada beberapa perpustakaan pihak ketiga yang mendukung Sisipan Massal yang tersedia:

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

Lihat: Entity Framework Bulk Insert library

Hati-hati, saat memilih perpustakaan sisipan massal. Hanya Entity Framework Extensions yang mendukung semua jenis asosiasi dan warisan dan hanya itu yang masih didukung.

Penafian : Saya adalah pemilik Entity Framework Extensions

Perpustakaan ini memungkinkan Anda untuk melakukan semua operasi massal yang Anda butuhkan untuk skenario Anda:

• Perubahan Simpan Massal
• Sisipkan Massal
• Hapus Massal
• Pembaruan Massal
• Gabung Massal

Contoh

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

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

Salah satu cara tercepat untuk menyimpan daftar Anda harus menerapkan kode berikut

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

AutoDetectChangesEnabled = false

Tambah, AddRange & SaveChanges: Tidak mendeteksi perubahan.

ValidateOnSaveEnabled = false;

Tidak mendeteksi pelacak perubahan

Anda harus menambahkan nuget

Install-Package Z.EntityFramework.Extensions

Sekarang Anda dapat menggunakan kode berikut

var context = new MyContext();

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

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

SqlBulkCopy super cepat

Ini implementasi saya:

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

[Pembaruan 2019] EF Core 3.1

Mengikuti apa yang telah dikatakan di atas, menonaktifkan AutoDetectChangesEnabled di EF Core bekerja dengan sempurna: waktu penyisipan dibagi dengan 100 (dari beberapa menit hingga beberapa detik, catatan 10k dengan hubungan lintas tabel)

Kode yang diperbarui adalah:

  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

Berikut ini adalah perbandingan kinerja antara menggunakan Entity Framework dan menggunakan kelas SqlBulkCopy pada contoh realistis: Bagaimana Cara Massal Memasukkan Objek Kompleks ke dalam Database SQL Server

Seperti yang sudah ditekankan oleh orang lain, ORM tidak dimaksudkan untuk digunakan dalam operasi massal. Mereka menawarkan fleksibilitas, pemisahan kekhawatiran dan manfaat lainnya, tetapi operasi massal (kecuali pembacaan massal) bukan salah satunya.

Pilihan lain adalah menggunakan SqlBulkTools yang tersedia dari Nuget. Ini sangat mudah digunakan dan memiliki beberapa fitur canggih.

Contoh:

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

Lihat dokumentasi untuk contoh lebih lanjut dan penggunaan lanjutan. Penafian: Saya adalah penulis perpustakaan ini dan pandangan saya adalah pendapat saya sendiri.

Sesuai pengetahuan saya ada no BulkInsertdiEntityFramework untuk meningkatkan kinerja sisipan besar.

Dalam skenario ini Anda dapat pergi dengan SqlBulkCopy di ADO.netuntuk memecahkan masalah Anda

Pernahkah Anda mencoba memasukkan melalui pekerja latar belakang atau tugas?

Dalam kasus saya, saya memasukkan register 7760, didistribusikan di 182 tabel berbeda dengan hubungan kunci asing (oleh NavigationProperties).

Tanpa tugas, butuh 2 menit setengah. Dalam Tugas (Task.Factory.StartNew(...) ), butuh 15 detik.

Saya hanya melakukan SaveChanges()setelah menambahkan semua entitas ke konteks. (untuk memastikan integritas data)

Semua solusi yang ditulis di sini tidak membantu karena ketika Anda melakukan SaveChanges (), masukkan pernyataan dikirim ke database satu per satu, itulah cara Entity bekerja.

Dan jika perjalanan Anda ke database dan kembali adalah 50 ms misalnya maka waktu yang diperlukan untuk memasukkan adalah jumlah catatan x 50 ms.

Anda harus menggunakan BulkInsert, ini tautannya: https://efbulkinsert.codeplex.com/

Saya mendapat waktu memasukkan berkurang dari 5-6 menit menjadi 10-12 detik dengan menggunakannya.

Anda dapat menggunakan pustaka paket massal . Versi Insert Massal 1.0.0 digunakan dalam proyek yang memiliki kerangka kerja Entitas> = 6.0.0.

Keterangan lebih lanjut dapat ditemukan di sini- kode sumber Operasi Massal

[SOLUSI BARU UNTUK POSTGRESQL] Hei, saya tahu ini posting yang cukup lama, tapi saya baru saja mengalami masalah yang sama, tetapi kami menggunakan Postgresql. Saya ingin menggunakan bulkinsert yang efektif, yang ternyata cukup sulit. Saya belum menemukan perpustakaan gratis yang tepat untuk melakukannya pada DB ini. Saya hanya menemukan pembantu ini: https://bytefish.de/blog/postgresql_bulk_insert/ yang juga ada di Nuget. Saya telah menulis mapper kecil, yang secara otomatis memetakan properti dengan cara 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;
        }

Saya menggunakannya dengan cara berikut (Saya memiliki entitas bernama Undertaking):

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

Saya menunjukkan contoh dengan transaksi, tetapi juga bisa dilakukan dengan koneksi normal yang diambil dari konteks. undertakingsToAdd adalah enumerable dari catatan entitas normal, yang ingin saya masukkan ke DB.

Solusi ini, yang saya dapatkan setelah beberapa jam meneliti dan mencoba, adalah seperti yang Anda harapkan jauh lebih cepat dan akhirnya mudah digunakan dan gratis! Saya benar-benar menyarankan Anda untuk menggunakan solusi ini, tidak hanya karena alasan yang disebutkan di atas, tetapi juga karena itu satu-satunya yang saya tidak punya masalah dengan Postgresql itu sendiri, banyak solusi lain bekerja dengan sempurna misalnya dengan SqlServer.

Rahasianya adalah memasukkan ke dalam tabel pementasan kosong yang identik. Sisipan cepat keringanan. Kemudian jalankan satu insert dari itu ke dalam tabel besar utama Anda. Kemudian potong tabel pementasan siap untuk batch berikutnya.

yaitu.

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

Tapi, untuk lebih dari (+4000) sisipan saya sarankan untuk menggunakan prosedur tersimpan. terlampir waktu berlalu. Saya memang memasukkannya 11.788 baris dalam 20 "

itu kode itu

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

Gunakan prosedur tersimpan yang mengambil input data dalam bentuk xml untuk memasukkan data.

Dari kode c # Anda, masukkan data yang dimasukkan sebagai xml.

misal dalam c #, sintaksnya akan seperti ini:

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

Gunakan teknik ini untuk meningkatkan kecepatan memasukkan catatan dalam Entity Framework. Di sini saya menggunakan prosedur tersimpan sederhana untuk memasukkan catatan. Dan untuk menjalankan prosedur tersimpan ini saya menggunakan metode .FromSql () dari Entity Framework yang mengeksekusi Raw SQL.

Kode prosedur yang tersimpan:

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

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

Selanjutnya, lewati semua 4000 record Anda dan tambahkan kode Entity Framework yang mengeksekusi yang tersimpan

onces prosedur setiap loop ke-100.

Untuk ini saya membuat kueri string untuk menjalankan prosedur ini, terus menambahkannya setiap set catatan.

Kemudian periksa apakah loop berjalan dalam kelipatan 100 dan dalam hal itu jalankan menggunakan .FromSql().

Jadi untuk 4000 rekaman saya hanya perlu menjalankan prosedur hanya 4000/100 = 40 kali .

Periksa kode di bawah ini:

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