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

Question

我目前收到此错误：

System.Data.SqlClient.SqlException：不允许新事务，因为会话中还有其他线程正在运行。

运行此代码时：

public class ProductManager : IProductManager
{
    #region Declare Models
    private RivWorks.Model.Negotiation.RIV_Entities _dbRiv = RivWorks.Model.Stores.RivEntities(AppSettings.RivWorkEntities_connString);
    private RivWorks.Model.NegotiationAutos.RivFeedsEntities _dbFeed = RivWorks.Model.Stores.FeedEntities(AppSettings.FeedAutosEntities_connString);
    #endregion

    public IProduct GetProductById(Guid productId)
    {
        // Do a quick sync of the feeds...
        SyncFeeds();
        ...
        // get a product...
        ...
        return product;
    }

    private void SyncFeeds()
    {
        bool found = false;
        string feedSource = "AUTO";
        switch (feedSource) // companyFeedDetail.FeedSourceTable.ToUpper())
        {
            case "AUTO":
                var 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;
                    foreach (RivWorks.Model.Negotiation.AutoNegotiationDetails companyFeedDetail in companyFeedDetailList)
                    {
                        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 ### //
                        }
                    }
                }
                break;
        }
    }
}

模型#1 - 该模型位于我们的开发服务器上的数据库中。 模型 #1 http://content .screencast.com/users/Keith.Barrows/folders/Jing/media/bdb2b000-6e60-4af0-a7a1-2bb6b05d8bc1/Model1.png

模型 #2 - 该模型位于我们的 Prod 服务器上的数据库中，并且是通过自动提要每天更新。 替代文本 http://content。 screencast.com/users/Keith.Barrows/folders/Jing/media/4260259f-bce6-43d5-9d2a-017bd9a980d4/Model2.png

注意 - 模型 #1 中的红色圆圈项目是我用来“映射”到模型#2。请忽略模型#2 中的红色圆圈：这是我遇到的另一个问题，现已得到解答。

注意：我仍然需要进行 isDeleted 检查，这样如果它已从我们客户的库存中消失，我可以将其从 DB1 中软删除。

我想要做的就是，使用这个特定的代码，将 DB1 中的一家公司与 DB2 中的客户端连接起来，从 DB2 获取他们的产品列表，然后将其插入到 DB1（如果尚不存在）。第一次通过应该是库存的全部拉出。每次运行时都不会发生任何事情，除非夜间有新的库存进入 Feed。

所以最大的问题 - 如何解决我遇到的交易错误？我是否需要每次循环时删除并重新创建上下文（对我来说没有意义）？

Answer 1

下面的代码对我有用：

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

Answer 2

我的情况和上面其他人的情况类似。我有一个 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();

Answer 3

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

问题是，由于单个数据库事务比 for-each 循环花费的时间稍长，因此一旦较早的事务未完成，新的牵引就会抛出异常，因此解决方案是在 for-each 循环中创建一个新对象您正在进行数据库事务的位置。

对于上述场景，解决方案将是这样的：

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 ### //
                    }
                }

Answer 4

我有点晚了，但我也遇到了这个错误。我通过检查更新的值解决了这个问题。

我发现我的查询是错误的，并且有超过 250 多个编辑待处理。所以我纠正了我的查询，现在它可以正常工作了。

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

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

Answer 5

大多数答案都与循环有关。但我的问题不同。当我尝试在同一范围内使用多个 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");

        }


    }

Answer 6

在费尽心思之后，我发现 foreach 循环是罪魁祸首。需要做的是调用 EF，但将其返回到该目标类型的 IList 中，然后在 IList 上循环。

例子：

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

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

调用此方法的可查询对象必须是有序的。这是因为实体框架仅支持 IQueryable.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，显示了数据库创建的内容。

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

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

Answer 8

我们现已发布对 Connect 上出现的错误。我们建议的解决方法如下：

此错误是由于实体框架在 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();
    }
} 

Answer 9

事实上，您无法使用实体框架在 C# 中的 foreach 循环内保存更改。

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

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

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

Answer 10

只需将 context.SaveChanges() 放在 foreach（循环）结束后即可。

Answer 11

将您的可查询列表设置为 .ToList() ，它应该可以正常工作。

Answer 12

仅供参考：来自一本书，并调整了一些行，因为它仍然有效：

调用 SaveChanges() 方法开始一个事务，如果在迭代完成之前发生异常，该事务会自动回滚保留到数据库的所有更改；否则事务提交。您可能会想在每次实体更新或删除之后应用该方法，而不是在迭代完成之后应用该方法，尤其是在更新或删除大量实体时。

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

有时最好了解事情发生的原因;-)

Answer 13

始终将您的选择用作列表

，例如：

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

然后在保存更改时循环遍历集合

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

             }

Answer 14

从 EF5 迁移到 EF6 后，我们开始看到此错误“不允许新事务，因为会话中还有其他线程正在运行”。

Google 将我们带到这里，但我们没有在循环内调用 SaveChanges()。在从数据库读取数据的 foreach 循环中使用 ObjectContext.ExecuteFunction 执行存储过程时，会引发错误。

对 ObjectContext.ExecuteFunction 的任何调用都会将该函数包装在事务中。在已经有打开的读取器的情况下开始事务会导致错误。

可以通过设置以下选项来禁用事务中的 SP 包装。

_context.Configuration.EnsureTransactionsForFunctionsAndCommands = false;

EnsureTransactionsForFunctionsAndCommands 选项允许 SP 在不创建自己的事务的情况下运行，并且不再引发错误。

DbContextConfiguration.EnsureTransactionsForFunctionsAndCommands 属性

Answer 15

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

Answer 16

这里还有另外 2 个选项，允许您在 foreach 循环中调用 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()
}

Answer 17

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

Answer 18

我也面临着同样的问题。

下面是原因和解决方法。

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

确保在触发数据操作命令（如插入、更新）之前，您已经关闭了所有先前活动的 SQL 读取器。

最常见的错误是从数据库读取数据并返回值的函数。
例如像 isRecordExist 这样的函数。

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

Answer 19

因此，在项目中，我遇到了完全相同的问题，问题不在 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();

Answer 20

就我而言，当我通过 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
   }
}

Answer 21

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

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

作为参考，当您收到此错误时，您也可以检查表触发器。

Answer 22

我需要读取一个巨大的结果集并更新表中的一些记录。
我尝试按照 Drew Noakes 的 答案。

不幸的是，在 50000 条记录之后，我遇到了 OutofMemoryException。
答案实体框架大数据集，出于内存异常解释说，

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 属性的简单结构。

Answer 23

最近我在我的项目中遇到了同样的问题，所以发布我的经验，它可能会帮助一些和我一样的人。该问题是由于我循环访问 EF select 查询的结果（结果未检索到内存中）。

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