[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。

我对上面的@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();
    }
}

正如其他人所说，如果您想要真正好的插入性能，SqlBulkCopy是一种实现方法。

它的实现有点麻烦，但有一些库可以帮助您实现它。有一些库，但这次我将无耻地使用我自己的库：https://github.com/MikaelEliasson/EntityFramework.Utilities#batch-插入实体

您需要的唯一代码是：

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

那么它快多少？很难说，因为这取决于许多因素，计算机性能、网络、对象大小等。我所做的性能测试表明，如果您像其他答案中提到的那样优化EF配置，则可以在10秒左右以标准方式在本地主机上插入25k个实体。使用EFUtilities，大约需要300毫秒。更有趣的是，我使用这种方法在不到15秒内保存了大约300万个实体，平均每秒大约200万个实体。

当然，一个问题是若需要插入相关数据。这可以使用上述方法在sql server中高效地完成，但它需要您有一个Id生成策略，允许您在应用程序代码中为父级生成Id，以便您可以设置外键。这可以使用GUID或类似HiLo id生成的方法来完成。

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

我已经研究了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是最优的，也找不到任何合理的解释。

您应该考虑为此使用System.Data.SqlClient.SqlBulkCopy。这是文档，当然还有很多在线教程。

抱歉，我知道您正在寻找一个简单的答案来让EF做您想做的事情，但批量操作并不是ORM真正的用途。