我正在寻找插入实体框架的最快方法。
我之所以问这个问题，是因为您有一个活动的TransactionScope，并且插入量很大（4000+）。它可能会持续超过10分钟（事务的默认超时），这将导致事务不完整。
当前回答
保存列表的最快方法之一必须应用以下代码
context.Configuration.AutoDetectChangesEnabled = false;
context.Configuration.ValidateOnSaveEnabled = false;
AutoDetectChangesEnabled=false
添加、添加范围和保存更改：无法检测更改。
ValidateOnSaveEnabled=false；
未检测到更改跟踪器
您必须添加nuget
Install-Package Z.EntityFramework.Extensions
现在您可以使用以下代码
var context = new MyContext();
context.Configuration.AutoDetectChangesEnabled = false;
context.Configuration.ValidateOnSaveEnabled = false;
context.BulkInsert(list);
context.BulkSaveChanges();
其他回答
因为这里从未提到过，我想在这里重新推荐EFCore.BulkExtensions
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);
但是，对于超过（+4000）个插入，我建议使用存储过程。附上经过的时间。我确实插入了20英寸的11.788行
这就是代码
public void InsertDataBase(MyEntity entity)
{
repository.Database.ExecuteSqlCommand("sp_mystored " +
"@param1, @param2"
new SqlParameter("@param1", entity.property1),
new SqlParameter("@param2", entity.property2));
}
是的，SqlBulkUpdate确实是这类任务最快的工具。我想在.NETCore中找到“最省力”的通用方法，所以我最终使用了MarcGravell的优秀库FastMember，并为实体框架DB上下文编写了一个小小的扩展方法。工作速度极快：
using System.Collections.Generic;
using System.Linq;
using FastMember;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
namespace Services.Extensions
{
public static class DbContextExtensions
{
public static void BulkCopyToServer<T>(this DbContext db, IEnumerable<T> collection)
{
var messageEntityType = db.Model.FindEntityType(typeof(T));
var tableName = messageEntityType.GetSchema() + "." + messageEntityType.GetTableName();
var tableColumnMappings = messageEntityType.GetProperties()
.ToDictionary(p => p.PropertyInfo.Name, p => p.GetColumnName());
using (var connection = new SqlConnection(db.Database.GetDbConnection().ConnectionString))
using (var bulkCopy = new SqlBulkCopy(connection))
{
foreach (var (field, column) in tableColumnMappings)
{
bulkCopy.ColumnMappings.Add(field, column);
}
using (var reader = ObjectReader.Create(collection, tableColumnMappings.Keys.ToArray()))
{
bulkCopy.DestinationTableName = tableName;
connection.Open();
bulkCopy.WriteToServer(reader);
connection.Close();
}
}
}
}
}
对于您在问题评论中的评论：
“…保存更改（每个记录）。。。"
这是你能做的最糟糕的事情！对每个记录调用SaveChanges（）会大大降低批量插入的速度。我会做一些简单的测试，这很可能会提高性能：
在所有记录后调用SaveChanges（）一次。例如，在100条记录之后调用SaveChanges（）。例如，在100条记录之后调用SaveChanges（），并释放上下文并创建新的上下文。禁用更改检测
对于批量插入，我正在使用这样的模式进行工作和试验：
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;
}
我有一个测试程序，它将560.000个实体（9个标量财产，没有导航财产）插入数据库。使用此代码，它只需不到3分钟即可工作。
为了提高性能，在“许多”记录之后调用SaveChanges（）非常重要（“许多”约为100或1000）。它还提高了在SaveChanges之后释放上下文并创建新上下文的性能。这将从所有实体中清除上下文，SaveChanges不会这样做，实体仍然以状态Unchanged附加到上下文。正是由于上下文中附加实体的大小不断增加，才导致插入过程一步步变慢。因此，在一段时间后清除它是有帮助的。
以下是我的560000个实体的一些测量值：
commitCount=1，recreateContext=false：许多小时（这是您当前的过程）commitCount=100，recreateContext=false：超过20分钟commitCount=1000，recreateContext=false：242秒commitCount=10000，recreateContext=false：202秒commitCount=100000，recreateContext=false：199秒commitCount=1000000，recreateContext=false：内存不足异常commitCount=1，recreateContext=true:超过10分钟commitCount=10，recreateContext=true:241秒commitCount=100，recreateContext=true:164秒commitCount=1000，recreateContext=true:191秒
上述第一个测试中的行为是，性能非常非线性，并且随着时间的推移会大大降低。（“很多小时”是一个估计，我从未完成过这项测试，20分钟后我停在了50000个实体。）这种非线性行为在所有其他测试中都不那么重要。
我知道这是一个非常古老的问题，但这里的一个家伙说，他开发了一个扩展方法，可以在EF中使用批量插入，当我检查时，我发现这个库今天的价格是599美元（对于一个开发人员来说）。也许对于整个库来说这是有意义的，但是对于大容量插入来说这太多了。
这是我做的一个非常简单的扩展方法。我首先将其与数据库配对使用（不首先使用代码进行测试，但我认为这是一样的）。使用上下文名称更改YourEntitys：
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;
}
}
您可以对继承自IEnumerable的任何集合使用它，如下所示：
await context.BulkInsertAllAsync(items);
