我正在寻找插入实体框架的最快方法。
我之所以问这个问题，是因为您有一个活动的TransactionScope，并且插入量很大（4000+）。它可能会持续超过10分钟（事务的默认超时），这将导致事务不完整。
当前回答
我已经研究了Slauma的答案（这太棒了，感谢创意人），我已经减少了批量，直到达到最佳速度。查看Slauma的结果：
commitCount=1，recreateContext=true:超过10分钟commitCount=10，recreateContext=true:241秒commitCount=100，recreateContext=true:164秒commitCount=1000，recreateContext=true:191秒
可以看出，当从1移动到10，以及从10移动到100时，速度会增加，但从100到1000的插入速度会再次下降。
因此，我重点关注了当您将批量大小减少到10到100之间时会发生什么，下面是我的结果（我使用了不同的行内容，因此我的时间值不同）：
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
根据我的结果，批量大小的实际最佳值约为30。它小于10和100。问题是，我不知道为什么30是最优的，也找不到任何合理的解释。
其他回答
我对上面的@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;
}
}
用法：
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();
}
}
[POSTGRESQL的新解决方案]嘿，我知道这是一篇很老的文章，但我最近遇到了类似的问题，但我们使用的是Postgresql。我想使用有效的膨胀剂，但结果很难。我在这个数据库上找不到合适的免费库。我只找到了这个助手：https://bytefish.de/blog/postgresql_bulk_insert/也在Nuget上。我编写了一个小映射器，它以实体框架的方式自动映射财产：
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;
}
我使用它的方式如下（我有一个名为“承诺”的实体）：
var undertakingHelper = BulkMapper.CreateHelper<Model.Undertaking>("dbo", nameof(Model.Undertaking));
undertakingHelper.SaveAll(transaction.UnderlyingTransaction.Connection as Npgsql.NpgsqlConnection, undertakingsToAdd));
我展示了一个事务的示例，但它也可以通过从上下文中检索到的正常连接来完成。undertakingsToAdd是普通实体记录的枚举，我想将其批量插入数据库。
这个解决方案，我经过几个小时的研究和尝试后得到的，正如你所期望的那样，速度更快，最终易于使用和免费！我真的建议你使用这个解决方案，不仅因为上面提到的原因，而且因为它是唯一一个我对Postgresql本身没有问题的解决方案，许多其他解决方案都可以完美地工作，例如SqlServer。
您是否尝试过通过后台工作人员或任务插入？
在我的例子中，我插入了7760个寄存器，分布在182个具有外键关系的不同表中（通过NavigationProperties）。
没有这项任务，花了2分半钟。在一个Task（Task.Factory.StartNew（…））中，花费了15秒。
我只在将所有实体添加到上下文之后才执行SaveChanges（）。（确保数据完整性）
但是，对于超过（+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));
}
因为这里从未提到过，我想在这里重新推荐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);
