供你参考:来自一本书，一些行调整，因为它仍然有效:

调用SaveChanges()方法将启动一个事务，如果在迭代完成之前发生异常，该事务将自动回滚持久化到数据库的所有更改;否则事务将提交。您可能倾向于在每次实体更新或删除之后应用该方法，而不是在迭代完成之后，特别是当您更新或删除大量实体时。

如果在处理完所有数据之前尝试调用SaveChanges()，则会引发“不允许新事务，因为会话中正在运行其他线程”异常。出现异常是因为SQL Server不允许在一个打开了SqlDataReader的连接上启动一个新事务，即使连接字符串启用了多个活动记录集(MARS) (EF的默认连接字符串启用了MARS)。

有时候理解事情为什么会发生会更好;-)

如果您由于foreach而得到这个错误，并且您确实需要在循环中首先保存一个实体，并在循环中进一步使用生成的标识，就像我的情况一样，最简单的解决方案是使用另一个DBContext来插入实体，该实体将返回Id并在外部上下文中使用这个Id

例如

    using (var context = new DatabaseContext())
    {
        ...
        using (var context1 = new DatabaseContext())
        {
            ...
               context1.SaveChanges();
        }                         
        //get id of inserted object from context1 and use is.   
      context.SaveChanges();
   }

正如您已经确定的那样，您不能在仍然通过活动读取器从数据库中提取数据的foreach中进行保存。

调用ToList()或ToArray()适用于小型数据集，但当您有数千行时，将消耗大量内存。

最好以块的形式加载行。

public static class EntityFrameworkUtil
{
    public static IEnumerable<T> QueryInChunksOf<T>(this IQueryable<T> queryable, int chunkSize)
    {
        return queryable.QueryChunksOfSize(chunkSize).SelectMany(chunk => chunk);
    }

    public static IEnumerable<T[]> QueryChunksOfSize<T>(this IQueryable<T> queryable, int chunkSize)
    {
        int chunkNumber = 0;
        while (true)
        {
            var query = (chunkNumber == 0)
                ? queryable 
                : queryable.Skip(chunkNumber * chunkSize);
            var chunk = query.Take(chunkSize).ToArray();
            if (chunk.Length == 0)
                yield break;
            yield return chunk;
            chunkNumber++;
        }
    }
}

给定上面的扩展方法，你可以这样写你的查询:

foreach (var client in clientList.OrderBy(c => c.Id).QueryInChunksOf(100))
{
    // do stuff
    context.SaveChanges();
}

调用此方法的可查询对象必须是有序的。这是因为实体框架只支持IQueryable<T>. skip (int)有序查询，当你考虑到多个不同范围的查询需要稳定的排序时，这是有意义的。如果顺序对您不重要，只需按主键排序，因为主键可能有聚集索引。

这个版本将以100个为单位批量查询数据库。注意，SaveChanges()是为每个实体调用的。

如果希望显著提高吞吐量，应该减少调用SaveChanges()的频率。请使用如下代码:

foreach (var chunk in clientList.OrderBy(c => c.Id).QueryChunksOfSize(100))
{
    foreach (var client in chunk)
    {
        // do stuff
    }
    context.SaveChanges();
}

这将减少100倍的数据库更新调用。当然，每一个调用都需要更长的时间来完成，但最终你仍然遥遥领先。你的里程可能不同，但这对我来说是快得多的。

它绕过了你看到的异常。

在运行SQL Profiler后，我重新审视了这个问题，并更新了一些东西来提高性能。对于感兴趣的人，这里有一些示例SQL，展示了DB创建的内容。

第一个循环不需要跳过任何内容，因此更简单。

SELECT TOP (100)                     -- the chunk size 
[Extent1].[Id] AS [Id], 
[Extent1].[Name] AS [Name], 
FROM [dbo].[Clients] AS [Extent1]
ORDER BY [Extent1].[Id] ASC

后续调用需要跳过之前的结果块，因此引入了row_number的用法:

SELECT TOP (100)                     -- the chunk size
[Extent1].[Id] AS [Id], 
[Extent1].[Name] AS [Name], 
FROM (
    SELECT [Extent1].[Id] AS [Id], [Extent1].[Name] AS [Name], row_number()
    OVER (ORDER BY [Extent1].[Id] ASC) AS [row_number]
    FROM [dbo].[Clients] AS [Extent1]
) AS [Extent1]
WHERE [Extent1].[row_number] > 100   -- the number of rows to skip
ORDER BY [Extent1].[Id] ASC

大部分答案与循环有关。但我的问题不同。当我试图在同一范围内使用多个dbcontext.Savechanges()命令时，我多次得到错误。

在我的案例中使用ef core 3.1

dbcontext.Database.BeginTransaction () 而且 dbcontext.Database.CommitTransaction ();

已经解决了问题。以下是我的全部代码:

 public IActionResult ApplyForCourse()
    {

        var master = _userService.GetMasterFromCurrentUser();

            var trainee = new Trainee
            {
                CourseId = courseId,
                JobStatus = model.JobStatus,
                Gender = model.Gender,
                Name = model.Name,
                Surname = model.Surname,
                Telephone = model.Telephone,
                Email = model.Email,
                BirthDate = model.BirthDate,
                Description = model.Description,
                EducationStatus = EducationStatus.AppliedForEducation,
                TraineeType = TraineeType.SiteFirst

            };


            dbcontext.Trainees.Add(trainee);
            dbcontext.SaveChanges();

         
            dbcontext.Database.BeginTransaction();
            var user = userManager.GetUserAsync(User).Result;
            master.TraineeId = trainee.Id;
            master.DateOfBirth = model.BirthDate;
            master.EducationStatus = trainee.EducationStatus;
            user.Gender = model.Gender;
            user.Email = model.Email;
            dbcontext.Database.CommitTransaction();
            dbcontext.SaveChanges();
 
            return RedirectToAction("Index", "Home");

        }


    }

最近我在我的项目中遇到了同样的问题，所以把我的经验发布出来，它可能会帮助一些和我在同一条船上的人。问题是由于我正在循环EF选择查询的结果(结果没有检索到内存)。

var products = (from e in _context.Products
                              where e.StatusId == 1
                              select new { e.Name, e.Type });

        foreach (var product in products)
        {
           //doing some insert EF Queries
           //some EF select quries
            await _context.SaveChangesAsync(stoppingToken); // This code breaks.
        }

我已经更新了我的产品选择查询，将结果带入LIST而不是IQueryable(这似乎是在为每个循环打开阅读器，因此保存失败)。

 var products = (from e in _context.Products
                              where e.StatusId == 1
                              select new { e.Name, e.Type })**.ToList()**; //see highlighted

I was getting this same issue but in a different situation. I had a list of items in a list box. The user can click an item and select delete but I am using a stored proc to delete the item because there is a lot of logic involved in deleting the item. When I call the stored proc the delete works fine but any future call to SaveChanges will cause the error. My solution was to call the stored proc outside of EF and this worked fine. For some reason when I call the stored proc using the EF way of doing things it leaves something open.