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

但是，对于超过（+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));
    }

如果您添加的实体（）依赖于上下文中的其他预加载实体（例如导航财产），则Dispose（）上下文会产生问题

我使用类似的概念来保持我的上下文较小，以实现相同的性能

但我只是分离已经SaveChanges（）的实体，而不是Dispose（）上下文并重新创建

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

如果需要，用try-catch和TrasactionScope（）将其包装起来，为了保持代码干净，没有在这里显示它们

秘密是插入到相同的空白暂存表中。插件快速发光。然后在主大表中运行一个单独的插入。然后截断临时表，为下一批做好准备。

ie.

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

对于您在问题评论中的评论：

“…保存更改（每个记录）。。。"

这是你能做的最糟糕的事情！对每个记录调用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个实体。）这种非线性行为在所有其他测试中都不那么重要。

您是否尝试过通过后台工作人员或任务插入？

在我的例子中，我插入了7760个寄存器，分布在182个具有外键关系的不同表中（通过NavigationProperties）。

没有这项任务，花了2分半钟。在一个Task（Task.Factory.StartNew（…））中，花费了15秒。

我只在将所有实体添加到上下文之后才执行SaveChanges（）。（确保数据完整性）