来自实体框架的SqlException - 不允许新事务，因为会话中还有其他线程在运行

19 回答

• 1

  经过多次拔毛后，我发现 foreach 循环是罪魁祸首 . 需要做的是调用EF但将其返回到该目标类型的 IList<T> 然后循环 IList<T> .

  例：

  IList<Client> clientList = from a in _dbFeed.Client.Include("Auto") select a;
  foreach (RivWorks.Model.NegotiationAutos.Client client in clientList)
  {
     var companyFeedDetailList = from a in _dbRiv.AutoNegotiationDetails where a.ClientID == client.ClientID select a;
      // ...
  }
  

  回复于 2024-05-04T02:37:16+08:00
• 7

  正如您已经确定的那样，您无法从仍通过活动阅读器从数据库中提取的 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();
  }
  

  The queryable object you call this method on must be ordered. 这是因为实体框架仅在有序查询上支持 IQueryable<T>.Skip(int) ，当您考虑到不同范围的多个查询要求排序稳定时，这是有意义的 . 如果排序不是't important to you, just order by primary key as that'可能有聚簇索引 .

  此版本将以100个批次查询数据库 . 请注意，为每个实体调用 SaveChanges() .

  如果您想要显着提高吞吐量，则应该更少地调用 SaveChanges() . 使用这样的代码：

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

  这导致数据库更新调用减少了100倍 . 当然，每个调用都需要更长的时间才能完成，但最终你还是会走在前面 . 你的里程可能会有所不同，但这对我来说更快 .

  它绕过你所看到的例外 .

  EDIT 我在运行SQL事件探查器后重新审视了这个问题并更新了一些内容以提高性能 . 对于任何感兴趣的人，这里有一些示例SQL，显示数据库创建的内容 .

  第一个循环不需要跳过任何东西，因此更简单 .

  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
  

  回复于 2024-05-04T02:37:16+08:00
• 1

  仅供参考：从一本书和一些行调整，因为它有效：

  调用SaveChanges（）方法开始一个事务，如果在迭代完成之前发生异常，它会自动回滚持久存储到数据库的所有更改;否则交易提交 . 您可能想要在每次实体更新或删除后应用该方法，而不是在迭代完成后应用该方法，尤其是在您更新或删除大量实体时 .

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

  有时候更好地理解事情发生的原因;-)

  回复于 2024-05-04T02:37:16+08:00
• 14

  我有点晚了，但我也有这个错误 . 我通过检查更新位置的值来解决问题 .

  我发现我的查询错误，并且有超过250个编辑待定 . 所以我更正了我的查询，现在它的工作正确 .

  所以在我的情况下：通过调试查询返回的结果来检查查询是否有错误 . 之后更正查询 .

  希望这有助于解决未来的问题 .

  回复于 2024-05-04T02:37:16+08:00
• 4

  我们现在已经发布了对the bug opened on Connect的官方回复 . 我们推荐的解决方法如下：

  此错误是由于Entity Framework在SaveChanges（）调用期间创建隐式事务 . 解决错误的最佳方法是使用不同的模式（即，在读取过程中不保存）或明确声明事务 . 这里有三种可能解决方案：

  // 1: Save after iteration (recommended approach in most cases)
  using (var context = new MyContext())
  {
      foreach (var person in context.People)
      {
          // Change to person
      }
      context.SaveChanges();
  }
  
  // 2: Declare an explicit transaction
  using (var transaction = new TransactionScope())
  {
      using (var context = new MyContext())
      {
          foreach (var person in context.People)
          {
              // Change to person
              context.SaveChanges();
          }
      }
      transaction.Complete();
  }
  
  // 3: Read rows ahead (Dangerous!)
  using (var context = new MyContext())
  {
      var people = context.People.ToList(); // Note that this forces the database
                                            // to evaluate the query immediately
                                            // and could be very bad for large tables.
  
      foreach (var person in people)
      {
          // Change to person
          context.SaveChanges();
      }
  }
  

  回复于 2024-05-04T02:37:16+08:00
• 245

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

  我发现，当数据库表触发器出错时，可能会抛出此错误 .

  为了您的信息，当您收到此错误时，您也可以检查您的表触发器 .

  回复于 2024-05-04T02:37:16+08:00
• 115

  始终将您的选择用作列表

  例如：

  var tempGroupOfFiles = Entities.Submited_Files.Where(r => r.FileStatusID == 10 && r.EventID == EventId).ToList();
  

  然后在保存更改时循环访问Collection

  foreach (var item in tempGroupOfFiles)
               {
                   var itemToUpdate = item;
                   if (itemToUpdate != null)
                   {
                       itemToUpdate.FileStatusID = 8;
                       itemToUpdate.LastModifiedDate = DateTime.Now;
                   }
                   Entities.SaveChanges();
  
               }
  

  回复于 2024-05-04T02:37:16+08:00
• 4

  以下代码适用于我：

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

  回复于 2024-05-04T02:37:16+08:00
• 3

  我也面临同样的问题 .

  这是原因和解决方案 .

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

  确保在触发数据操作命令（如插入，更新）之前，您已关闭所有以前的活动SQL阅读器 .

  最常见的错误是从db读取数据并返回值的函数 . 对于像isRecordExist这样的函数 .

  在这种情况下，如果我们找到记录并忘记关闭阅读器，我们会立即从函数返回 .

  回复于 2024-05-04T02:37:16+08:00
• 0

  如果由于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();
     }
  

  回复于 2024-05-04T02:37:16+08:00
• 2

  将您的可查询列表设为.ToList（），它应该可以正常工作 .

  回复于 2024-05-04T02:37:16+08:00
• 0

  所以在项目中我有这个完全相同的问题，问题不在 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();
  

  回复于 2024-05-04T02:37:16+08:00
• 1

  只需在 foreach （循环）结束后输入 context.SaveChanges() .

  回复于 2024-05-04T02:37:16+08:00
• 0

  以下是另外两个选项，允许您在每个循环中调用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()
  }
  

  回复于 2024-05-04T02:37:16+08:00
• 4

  实际上，您无法使用Entity Framework在C＃中的 foreach 循环中保存更改 .

  context.SaveChanges() 方法的作用类似于常规数据库系统（RDMS）上的提交 .

  只需进行所有更改（实体框架将缓存），然后在循环之后（在其外部）调用 SaveChanges() ，同时保存所有更改，就像数据库提交命令一样 .

  如果您可以一次保存所有更改，则此方法有效 .

  回复于 2024-05-04T02:37:16+08:00
• 597

  我遇到了同样的问题，但处于不同的情况 . 我在列表框中有一个项目列表 . 用户可以单击一个项目并选择删除，但我使用存储过程删除该项目，因为删除项目涉及很多逻辑 . 当我调用存储过程时，删除工作正常，但将来调用SaveChanges将导致错误 . 我的解决方案是在EF之外调用存储过程，这很好 . 出于某种原因，当我使用EF处理方式调用存储过程时，它会留下一些东西 .

  回复于 2024-05-04T02:37:16+08:00
• 0

  在我的情况下，当我通过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
     }
  }
  

  回复于 2024-05-04T02:37:16+08:00
• -1

  我需要读取一个巨大的ResultSet并更新表中的一些记录 . 我尝试使用Drew Noakes的answer中建议的块 .

  不幸的是，在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属性的简单结构 .

  回复于 2024-05-04T02:37:16+08:00
• 0

  我迟到了，但今天我遇到了同样的错误，我的解决方法很简单 . 我的场景类似于给定的代码我在嵌套for-each循环中进行数据库事务 .

  问题是因为单个数据库事务比每个循环花费的时间要长一点，所以一旦先前的事务没有完成，那么新牵引会引发异常，因此解决方案是在for-each循环中创建一个新对象，在该循环中进行db事务 .

  对于上述场景，解决方案将如下所示：

  foreach (RivWorks.Model.Negotiation.AutoNegotiationDetails companyFeedDetail in companyFeedDetailList)
                  {
  private RivWorks.Model.Negotiation.RIV_Entities _dbRiv = RivWorks.Model.Stores.RivEntities(AppSettings.RivWorkEntities_connString);
                      if (companyFeedDetail.FeedSourceTable.ToUpper() == "AUTO")
                      {
                          var company = (from a in _dbRiv.Company.Include("Product") where a.CompanyId == companyFeedDetail.CompanyId select a).First();
                          foreach (RivWorks.Model.NegotiationAutos.Auto sourceProduct in client.Auto)
                          {
                              foreach (RivWorks.Model.Negotiation.Product targetProduct in company.Product)
                              {
                                  if (targetProduct.alternateProductID == sourceProduct.AutoID)
                                  {
                                      found = true;
                                      break;
                                  }
                              }
                              if (!found)
                              {
                                  var newProduct = new RivWorks.Model.Negotiation.Product();
                                  newProduct.alternateProductID = sourceProduct.AutoID;
                                  newProduct.isFromFeed = true;
                                  newProduct.isDeleted = false;
                                  newProduct.SKU = sourceProduct.StockNumber;
                                  company.Product.Add(newProduct);
                              }
                          }
                          _dbRiv.SaveChanges();  // ### THIS BREAKS ### //
                      }
                  }
  

  回复于 2024-05-04T02:37:16+08:00