Tôi đang tìm cách nhanh nhất để chèn vào Entity Framework.

Tôi đang hỏi điều này vì kịch bản mà bạn có một Giao dịch viên đang hoạt động và phần chèn rất lớn (4000+). Nó có khả năng có thể kéo dài hơn 10 phút (thời gian chờ giao dịch mặc định) và điều này sẽ dẫn đến một giao dịch không hoàn chỉnh.

Nhận xét của bạn trong các ý kiến ​​cho câu hỏi của bạn:

"... SavingChanges ( cho mỗi bản ghi ) ..."

Đó là điều tồi tệ nhất bạn có thể làm! Gọi SaveChanges()cho mỗi bản ghi làm chậm chèn số lượng lớn vô cùng. Tôi sẽ làm một vài thử nghiệm đơn giản rất có thể sẽ cải thiện hiệu suất:

• Gọi SaveChanges()một lần sau TẤT CẢ hồ sơ.
• Gọi SaveChanges()sau ví dụ 100 hồ sơ.
• Gọi SaveChanges() sau ví dụ 100 bản ghi và xử lý bối cảnh và tạo một bản mới.
• Vô hiệu hóa phát hiện thay đổi

Đối với các phần chèn lớn, tôi đang làm việc và thử nghiệm một mẫu như thế này:

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

Tôi có một chương trình thử nghiệm chèn 560.000 thực thể (9 thuộc tính vô hướng, không có thuộc tính điều hướng) vào DB. Với mã này, nó hoạt động trong ít hơn 3 phút.

Đối với hiệu suất, điều quan trọng là gọi SaveChanges()sau "nhiều" bản ghi ("nhiều" khoảng 100 hoặc 1000). Nó cũng cải thiện hiệu suất để xử lý bối cảnh sau SaveChanges và tạo một bối cảnh mới. Điều này xóa bối cảnh khỏi tất cả các mục nhập, SaveChangeskhông làm điều đó, các thực thể vẫn được gắn liền với bối cảnh ở trạng thái Unchanged. Đó là kích thước ngày càng tăng của các thực thể đính kèm trong bối cảnh làm chậm từng bước chèn. Vì vậy, nó là hữu ích để xóa nó sau một thời gian.

Dưới đây là một vài phép đo cho 560000 thực thể của tôi:

• commitCount = 1, createdeContext = false: nhiều giờ (Đó là thủ tục hiện tại của bạn)
• commitCount = 100, createdeContext = false: hơn 20 phút
• commitCount = 1000, createdeContext = false: 242 giây
• commitCount = 10000, createdeContext = false: 202 giây
• commitCount = 100000, createdeContext = false: 199 giây
• commitCount = 1000000, createdeContext = false: ngoại lệ bộ nhớ
• commitCount = 1, createdeContext = true: hơn 10 phút
• commitCount = 10, createdeContext = true: 241 giây
• commitCount = 100, createdeContext = true: 164 giây
• commitCount = 1000, createdeContext = true: 191 giây

Hành vi trong thử nghiệm đầu tiên ở trên là hiệu suất rất phi tuyến tính và giảm cực kỳ theo thời gian. ("Nhiều giờ" là một ước tính, tôi chưa bao giờ hoàn thành bài kiểm tra này. Tôi đã dừng lại ở 50.000 thực thể sau 20 phút.) Hành vi phi tuyến tính này không quá quan trọng trong tất cả các thử nghiệm khác.

Sự kết hợp này tăng tốc độ đủ tốt.

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

Cách nhanh nhất sẽ là sử dụng tiện ích mở rộng chèn số lượng lớn mà tôi đã phát triển

lưu ý: đây là sản phẩm thương mại, không miễn phí

Nó sử dụng SqlBulkCopy và bộ dữ liệu tùy chỉnh để có được hiệu suất tối đa. Kết quả là nó nhanh hơn 20 lần so với sử dụng chèn hoặc AddRange thông thường

cách sử dụng cực kỳ đơn giản

context.BulkInsert(hugeAmountOfEntities);

Bạn nên nhìn vào việc sử dụng System.Data.SqlClient.SqlBulkCopycho việc này. Đây là tài liệu , và tất nhiên có rất nhiều hướng dẫn trực tuyến.

Xin lỗi, tôi biết bạn đang tìm kiếm một câu trả lời đơn giản để khiến EF thực hiện những gì bạn muốn, nhưng các hoạt động hàng loạt không thực sự là ý nghĩa của ORM.

Tôi đồng ý với Adam Rackis. SqlBulkCopylà cách nhanh nhất để chuyển các bản ghi hàng loạt từ nguồn dữ liệu này sang nguồn dữ liệu khác. Tôi đã sử dụng điều này để sao chép hồ sơ 20K và chỉ mất chưa đến 3 giây. Hãy xem ví dụ dưới đây.

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

    }
}

Tôi muốn giới thiệu bài viết này về cách thực hiện chèn số lượng lớn bằng cách sử dụng EF.

Khung thực thể và CHỨNG MINH số lượng lớn chậm

Anh khám phá những lĩnh vực này và so sánh sự hoàn hảo:

1. Mặc định EF (57 phút để hoàn thành thêm 30.000 hồ sơ)
2. Thay thế bằng Mã ADO.NET (25 giây cho cùng 30.000)
3. Bối cảnh bối cảnh- Giữ đồ thị ngữ cảnh hoạt động nhỏ bằng cách sử dụng bối cảnh mới cho mỗi Đơn vị công việc (cùng 30.000 lần chèn mất 33 giây)
4. Danh sách lớn - Tắt AutoDetectChangesEnables (giảm thời gian xuống còn khoảng 20 giây)
5. Batching (giảm xuống 16 giây)
6. DbTable.AddRange () - (hiệu suất nằm trong phạm vi 12)

vì nó chưa bao giờ được đề cập ở đây, tôi muốn giới thiệu EFCore.BulkExtensions tại đây

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

Tôi đã điều tra câu trả lời của Slauma (thật tuyệt vời, cảm ơn người đàn ông ý tưởng) và tôi đã giảm kích thước lô cho đến khi tôi đạt tốc độ tối ưu. Nhìn vào kết quả của Slauma:

• commitCount = 1, createdeContext = true: hơn 10 phút
• commitCount = 10, createdeContext = true: 241 giây
• commitCount = 100, createdeContext = true: 164 giây
• commitCount = 1000, createdeContext = true: 191 giây

Có thể thấy rằng có sự tăng tốc độ khi di chuyển từ 1 đến 10 và từ 10 đến 100, nhưng từ 100 đến 1000 tốc độ chèn lại giảm xuống.

Vì vậy, tôi đã tập trung vào những gì đang xảy ra khi bạn giảm kích thước lô xuống giá trị ở đâu đó trong khoảng từ 10 đến 100 và đây là kết quả của tôi (Tôi đang sử dụng các nội dung hàng khác nhau, vì vậy thời gian của tôi có giá trị khác nhau):

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

Dựa trên kết quả của tôi, tối ưu thực tế là khoảng 30 cho kích thước lô. Nó ít hơn cả 10 và 100. Vấn đề là, tôi không biết tại sao 30 tối ưu, tôi cũng không thể tìm thấy bất kỳ lời giải thích hợp lý nào cho nó.

Như những người khác đã nói SqlBulkCopy là cách để làm điều đó nếu bạn muốn hiệu suất chèn thực sự tốt.

Nó hơi cồng kềnh khi thực hiện nhưng có những thư viện có thể giúp bạn với nó. Có một vài cái ở ngoài đó nhưng tôi sẽ không biết xấu hổ cắm thư viện của riêng mình lần này: https://github.com/MikaelEliasson/EntityFramework.Utilities#batch-insert-entities

Mã duy nhất bạn cần là:

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

Vậy nó nhanh hơn bao nhiêu? Rất khó để nói vì nó phụ thuộc vào rất nhiều yếu tố, hiệu suất máy tính, mạng, kích thước đối tượng, v.v. Các thử nghiệm hiệu suất tôi đã thực hiện cho thấy các thực thể 25k có thể được chèn vào khoảng 10 giây theo cách tiêu chuẩn trên localhost NẾU bạn tối ưu hóa cấu hình EF của mình như đề cập trong các câu trả lời khác. Với EFUtilities mất khoảng 300ms. Điều thú vị hơn nữa là tôi đã lưu khoảng 3 triệu thực thể trong vòng dưới 15 giây bằng phương pháp này, trung bình khoảng 200 nghìn thực thể mỗi giây.

Một vấn đề là tất nhiên nếu bạn cần chèn dữ liệu liên quan. Điều này có thể được thực hiện một cách hiệu quả vào máy chủ sql bằng phương pháp trên nhưng nó yêu cầu bạn phải có chiến lược tạo Id cho phép bạn tạo id trong mã ứng dụng cho cha mẹ để bạn có thể đặt khóa ngoại. Điều này có thể được thực hiện bằng GUID hoặc một cái gì đó như thế hệ id HiLo.

Dispose()bối cảnh tạo ra vấn đề nếu các thực thể bạn Add()dựa vào các thực thể được tải sẵn khác (ví dụ: thuộc tính điều hướng) trong ngữ cảnh

Tôi sử dụng khái niệm tương tự để giữ cho bối cảnh của tôi nhỏ để đạt được hiệu suất tương tự

Nhưng thay vì Dispose()bối cảnh và tạo lại, tôi chỉ cần tách rời các thực thể đã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;
} }

bọc nó bằng thử bắt và TrasactionScope()nếu bạn cần, không hiển thị chúng ở đây để giữ mã sạch

Tôi biết đây là một câu hỏi rất cũ, nhưng một anh chàng ở đây đã nói rằng đã phát triển một phương pháp mở rộng để sử dụng chèn số lượng lớn với EF và khi tôi kiểm tra, tôi phát hiện ra rằng thư viện có giá $ 599 ngày hôm nay (cho một nhà phát triển). Có thể nó có ý nghĩa đối với toàn bộ thư viện, tuy nhiên đối với việc chèn số lượng lớn thì điều này là quá nhiều.

Đây là một phương pháp mở rộng rất đơn giản tôi đã thực hiện. Tôi sử dụng nó trên cặp với cơ sở dữ liệu trước tiên (không được kiểm tra bằng mã trước, nhưng tôi nghĩ rằng nó hoạt động như nhau). Thay đổi YourEntitiesvới tên của bối cảnh của bạn:

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

Bạn có thể sử dụng nó để chống lại bất kỳ bộ sưu tập nào kế thừa từ đó IEnumerable, như thế:

await context.BulkInsertAllAsync(items);

Cố gắng sử dụng một thủ tục được lưu trữ sẽ nhận được một XML dữ liệu mà bạn muốn chèn.

Tôi đã thực hiện một phần mở rộng chung của ví dụ @Slauma s ở trên;

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

Sử dụng:

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

Tôi đang tìm cách nhanh nhất để chèn vào Entity Framework

Có một số thư viện của bên thứ ba hỗ trợ Chèn hàng loạt có sẵn:

• Z.EntityFramework.Extensions ( Được khuyến nghị )
• Khả năng
• EntityFramework.BulkInsert

Xem: Thư viện Chèn hàng loạt khung thực thể

Hãy cẩn thận, khi chọn một thư viện chèn số lượng lớn. Chỉ phần mở rộng khung thực thể hỗ trợ tất cả các loại liên kết và kế thừa và đó là duy nhất vẫn được hỗ trợ.

Tuyên bố miễn trừ trách nhiệm : Tôi là chủ sở hữu của Phần mở rộng khung thực thể

Thư viện này cho phép bạn thực hiện tất cả các hoạt động hàng loạt bạn cần cho các tình huống của mình:

• Lưu số lượng lớn
• Chèn số lượng lớn
• Xóa hàng loạt
• Cập nhật hàng loạt
• Hợp nhất số lượng lớn

Thí dụ

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

Sử dụng 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;
}

Một trong những cách nhanh nhất để lưu danh sách, bạn phải áp dụng mã sau đây

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

AutoDetectChangesEnables = false

Thêm, AddRange & SaveChanges: Không phát hiện thay đổi.

ValidateOnSaveEnables = false;

Không phát hiện theo dõi thay đổi

Bạn phải thêm nuget

Install-Package Z.EntityFramework.Extensions

Bây giờ bạn có thể sử dụng mã sau đây

var context = new MyContext();

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

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

SqlBulkCopy là siêu nhanh

Đây là triển khai của tôi:

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

[Cập nhật 2019] EF Core 3.1

Theo những gì đã nói ở trên, việc vô hiệu hóa AutoDetectChangesEnables trong EF Core hoạt động hoàn hảo: thời gian chèn được chia cho 100 (từ nhiều phút đến vài giây, 10k bản ghi với các mối quan hệ bảng chéo)

Mã cập nhật là:

  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

Dưới đây là so sánh hiệu năng giữa việc sử dụng Entity Framework và sử dụng lớp SqlBulkCopy trên một ví dụ thực tế: Cách chèn hàng loạt các đối tượng phức tạp vào cơ sở dữ liệu SQL Server

Như những người khác đã nhấn mạnh, ORM không có nghĩa là được sử dụng trong các hoạt động hàng loạt. Họ cung cấp sự linh hoạt, tách biệt các mối quan tâm và các lợi ích khác, nhưng các hoạt động hàng loạt (ngoại trừ việc đọc số lượng lớn) không phải là một trong số đó.

Một tùy chọn khác là sử dụng SqlBulkTools có sẵn từ Nuget. Nó rất dễ sử dụng và có một số tính năng mạnh mẽ.

Thí dụ:

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

Xem tài liệu để biết thêm ví dụ và sử dụng nâng cao. Tuyên bố miễn trừ trách nhiệm: Tôi là tác giả của thư viện này và mọi quan điểm đều là quan điểm của riêng tôi.

Theo hiểu biết của tôi có no BulkInserttrong EntityFrameworkđể tăng hiệu suất của chèn khổng lồ.

Trong kịch bản này, bạn có thể đi với SqlBulkCopy trong ADO.netđể giải quyết vấn đề của bạn

Bạn đã bao giờ thử chèn thông qua một nhân viên nền hoặc nhiệm vụ?

Trong trường hợp của tôi, tôi đang chèn 7760 thanh ghi, được phân phối trong 182 bảng khác nhau với các mối quan hệ khóa ngoài (theo NavigationProperives).

Không có nhiệm vụ, phải mất 2 phút rưỡi. Trong một Nhiệm vụ ( Task.Factory.StartNew(...)), mất 15 giây.

Tôi chỉ làm SaveChanges()sau khi thêm tất cả các thực thể vào bối cảnh. (để đảm bảo tính toàn vẹn dữ liệu)

Tất cả các giải pháp được viết ở đây không giúp ích gì vì khi bạn thực hiện SaveChanges (), các câu lệnh chèn được gửi đến cơ sở dữ liệu từng cái một, đó là cách Entity hoạt động.

Và nếu chuyến đi của bạn đến cơ sở dữ liệu và trở lại là 50 ms chẳng hạn thì thời gian cần thiết để chèn là số lượng bản ghi x 50 ms.

Bạn phải sử dụng BulkInsert, đây là liên kết: https://efbulkinsert.codeplex.com/

Tôi đã giảm thời gian chèn từ 5-6 phút xuống còn 10-12 giây bằng cách sử dụng nó.

Bạn có thể sử dụng gói số lượng lớn thư viện . Phiên bản hàng loạt Chèn 1.0.0 được sử dụng trong các dự án có khung Entity> = 6.0.0.

Có thể tìm thấy thêm mô tả ở đây- Mã nguồn hàng loạt

[GIẢI PHÁP MỚI CHO POSTGRESQL] Này, tôi biết đó là một bài viết khá cũ, nhưng gần đây tôi đã gặp phải vấn đề tương tự, nhưng chúng tôi đã sử dụng Postgresql. Tôi muốn sử dụng bulkinsert hiệu quả, điều này hóa ra khá khó khăn. Tôi chưa tìm thấy bất kỳ thư viện miễn phí thích hợp nào để làm như vậy trên DB này. Tôi chỉ tìm thấy người trợ giúp này: https://bytefish.de/blog/postgresql_bulk_insert/ cũng có trên Nuget. Tôi đã viết một trình ánh xạ nhỏ, tự động ánh xạ các thuộc tính theo cách 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;
        }

Tôi sử dụng nó theo cách sau (tôi có thực thể tên là Cam kết):

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

Tôi đã đưa ra một ví dụ với giao dịch, nhưng nó cũng có thể được thực hiện với kết nối bình thường được lấy từ ngữ cảnh. undertakingsToAdd là vô số các bản ghi thực thể bình thường, mà tôi muốn đưa hàng loạt vào DB.

Giải pháp này, mà tôi đã nhận được sau vài giờ nghiên cứu và thử, là vì bạn có thể mong đợi nhanh hơn nhiều và cuối cùng dễ sử dụng và miễn phí! Tôi thực sự khuyên bạn nên sử dụng giải pháp này, không chỉ vì những lý do nêu trên mà còn bởi vì đó là giải pháp duy nhất mà tôi không gặp vấn đề gì với chính Postgresql, nhiều giải pháp khác hoạt động hoàn hảo, ví dụ như với SqlServer.

Bí quyết là chèn vào một bảng dàn trống giống hệt nhau. Chèn được làm sáng nhanh chóng. Sau đó chạy một đơn chèn từ đó vào bảng lớn chính của bạn. Sau đó cắt ngắn bảng dàn dựng sẵn sàng cho đợt tiếp theo.

I E.

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

Nhưng, trong hơn (4.000) phần chèn, tôi khuyên bạn nên sử dụng quy trình được lưu trữ. thời gian trôi qua. Tôi đã chèn nó 11.788 hàng trong 20 "

đó là mã

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

Sử dụng quy trình được lưu trữ lấy dữ liệu đầu vào dưới dạng xml để chèn dữ liệu.

Từ mã c # của bạn vượt qua chèn dữ liệu dưới dạng xml.

ví dụ: trong c #, cú pháp sẽ như thế này:

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

Sử dụng kỹ thuật này để tăng tốc độ chèn bản ghi trong Entity Framework. Ở đây tôi sử dụng một thủ tục lưu trữ đơn giản để chèn các hồ sơ. Và để thực hiện thủ tục được lưu trữ này, tôi sử dụng phương thức EntromSql () của Entity Framework để thực thi SQL thô.

Mã thủ tục được lưu trữ:

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

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

Tiếp theo, lặp qua tất cả 4000 hồ sơ của bạn và thêm mã Khung thực thể thực thi việc lưu trữ

thủ tục buộc mỗi vòng thứ 100.

Đối với điều này, tôi tạo một truy vấn chuỗi để thực hiện thủ tục này, tiếp tục nối thêm vào nó mỗi bộ bản ghi.

Sau đó kiểm tra nó, vòng lặp đang chạy trong bội số của 100 và trong trường hợp đó thực hiện nó bằng cách sử dụng .FromSql().

Vì vậy, đối với 4000 hồ sơ, tôi chỉ phải thực hiện thủ tục chỉ với 4000/100 = 40 lần .

Kiểm tra mã dưới đây:

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