Entity Framework中的SqlException - 因为会话中有其他线程正在运行，所以不允许新的事务。

如果你因为使用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();
   }

这里有另外两个选项，可以让你在for each循环中调用SaveChanges()。

第一个选项是使用一个DBContext生成要迭代的列表对象，然后创建第二个DBContext来调用SaveChanges()。下面是一个例子：

//Get your IQueryable list of objects from your main DBContext(db)    
IQueryable<Object> objects = db.Object.Where(whatever where clause you desire);

//Create a new DBContext outside of the foreach loop    
using (DBContext dbMod = new DBContext())
{   
    //Loop through the IQueryable       
    foreach (Object object in objects)
    {
        //Get the same object you are operating on in the foreach loop from the new DBContext(dbMod) using the objects id           
        Object objectMod = dbMod.Object.Find(object.id);

        //Make whatever changes you need on objectMod
        objectMod.RightNow = DateTime.Now;

        //Invoke SaveChanges() on the dbMod context         
        dbMod.SaveChanges()
    }
}

第二种选择是从DBContext获取数据库对象列表，但仅选择ID。然后遍历ID列表（可能是int类型），获取每个int对应的对象，并以此方式调用SaveChanges()。这种方法的思想是，获取大量整数列表比获取大量db对象并在整个对象上调用.ToList()要更有效率。以下是此方法的示例：

//Get the list of objects you want from your DBContext, and select just the Id's and create a list
List<int> Ids = db.Object.Where(enter where clause here)Select(m => m.Id).ToList();

var objects = Ids.Select(id => db.Objects.Find(id));

foreach (var object in objects)
{
    object.RightNow = DateTime.Now;
    db.SaveChanges()
}

我需要读取一个巨大的ResultSet并更新表中的一些记录。我尝试使用Drew Noakes在答案中建议的分块方法。

不幸的是，在50000条记录后，我遇到了OutOfMemoryException。答案Entity framework large data set, out of memory exception解释说：

EF创建了第二份数据副本，用于更改检测（以便它可以将更改持久化到数据库）。 EF将此第二组保留在上下文的生命周期内，而正是这个集合占用了你的内存。

建议是为每个批次重新创建上下文。

因此，我检索了主键的最小值和最大值——表具有自动递增整数作为主键。然后，我通过为每个块打开上下文从数据库中检索记录块。处理完块后，上下文关闭并释放内存。它确保内存使用量不会增长。

以下是我的代码片段：

  public void ProcessContextByChunks ()
  {
        var tableName = "MyTable";
         var startTime = DateTime.Now;
        int i = 0;
         var minMaxIds = GetMinMaxIds();
        for (int fromKeyID= minMaxIds.From; fromKeyID <= minMaxIds.To; fromKeyID = fromKeyID+_chunkSize)
        {
            try
            {
                using (var context = InitContext())
                {   
                    var chunk = GetMyTableQuery(context).Where(r => (r.KeyID >= fromKeyID) && (r.KeyID < fromKeyID+ _chunkSize));
                    try
                    {
                        foreach (var row in chunk)
                        {
                            foundCount = UpdateRowIfNeeded(++i, row);
                        }
                        context.SaveChanges();
                    }
                    catch (Exception exc)
                    {
                        LogChunkException(i, exc);
                    }
                }
            }
            catch (Exception exc)
            {
                LogChunkException(i, exc);
            }
        }
        LogSummaryLine(tableName, i, foundCount, startTime);
    }

    private FromToRange<int> GetminMaxIds()
    {
        var minMaxIds = new FromToRange<int>();
        using (var context = InitContext())
        {
            var allRows = GetMyTableQuery(context);
            minMaxIds.From = allRows.Min(n => (int?)n.KeyID ?? 0);  
            minMaxIds.To = allRows.Max(n => (int?)n.KeyID ?? 0);
        }
        return minMaxIds;
    }

    private IQueryable<MyTable> GetMyTableQuery(MyEFContext context)
    {
        return context.MyTable;
    }

    private  MyEFContext InitContext()
    {
        var context = new MyEFContext();
        context.Database.Connection.ConnectionString = _connectionString;
        //context.Database.Log = SqlLog;
        return context;
    }

FromToRange 是一个简单的结构体，具有 From 和 To 属性。

在我的情况下，当我通过EF调用存储过程，然后稍后SaveChanges时抛出了这个异常。问题出在调用存储过程上，枚举器没有被处理。我通过以下方式修复了代码：

public bool IsUserInRole(string username, string roleName, DataContext context)
{          
   var result = context.aspnet_UsersInRoles_IsUserInRoleEF("/", username, roleName);

   //using here solved the issue
   using (var en = result.GetEnumerator()) 
   {
     if (!en.MoveNext())
       throw new Exception("emty result of aspnet_UsersInRoles_IsUserInRoleEF");
     int? resultData = en.Current;

     return resultData == 1;//1 = success, see T-SQL for return codes
   }
}

我也遇到了同样的问题。
以下是原因和解决方法。

http://blogs.msdn.com/b/cbiyikoglu/archive/2006/11/21/mars-transactions-and-sql-error-3997-3988-or-3983.aspx

确保在执行数据操作命令（如插入、更新）之前，关闭所有先前活动的SQL读取器。
最常见的错误是从数据库中读取数据并返回值的函数。例如像isRecordExist这样的函数。
在这种情况下，如果我们找到了记录并忘记关闭读取器，则会立即从函数返回。

我知道这是一个老问题，但今天我遇到了这个错误。

我发现，当数据库表触发器出现错误时，就会抛出此错误。

有关你的信息，在你遇到这个错误时，你也可以检查你的表触发器。

所以在我遇到这个问题的项目中，问题不在foreach或.toList()中，而是在我们使用的AutoFac配置中。

这导致了一些奇怪的情况，上述错误被抛出，同时还抛出了一堆其他等效的错误。

这是我们的解决方法：

将此更改为：

container.RegisterType<DataContext>().As<DbContext>().InstancePerLifetimeScope();
container.RegisterType<DbFactory>().As<IDbFactory>().SingleInstance();
container.RegisterType<UnitOfWork>().As<IUnitOfWork>().InstancePerRequest();

致：

container.RegisterType<DataContext>().As<DbContext>().As<DbContext>();
container.RegisterType<DbFactory>().As<IDbFactory>().As<IDbFactory>().InstancePerLifetimeScope();
container.RegisterType<UnitOfWork>().As<IUnitOfWork>().As<IUnitOfWork>();//.InstancePerRequest();

最近，在我的项目中，我遇到了同样的问题，因此分享一下我的经验，希望能帮助一些和我一样的人。这个问题是由于我正在循环遍历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

我的情况与其他人类似。我有一个IQueryable，我正在其中进行foreach循环。这反过来调用了一个带有SaveChanges()方法的方法。由于上面的查询已经打开了一个事务，所以这里出现了异常。

// Example:

var myList = _context.Table.Where(x => x.time == null);

foreach(var i in myList)
{
    MyFunction(i); // <<-- Has _context.SaveChanges() which throws exception
}

在我的情况下，将ToList()添加到查询的末尾是解决方案。

// Fix
var myList = _context.Table.Where(x => x.time == null).ToList();

以下代码对我有效：

以下是代码：

private pricecheckEntities _context = new pricecheckEntities();

...

private void resetpcheckedtoFalse()
{
    try
    {
        foreach (var product in _context.products)
        {
            product.pchecked = false;
            _context.products.Attach(product);
            _context.Entry(product).State = EntityState.Modified;
        }
        _context.SaveChanges();
    }
    catch (Exception extofException)
    {
        MessageBox.Show(extofException.ToString());

    }
    productsDataGrid.Items.Refresh();
}