Entity Framework Core：在前一个操作完成之前在此上下文上启动了第二个操作

Question

我正在使用 Entity Framework Core 开发一个 ASP.Net Core 2.0 项目

<PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.0.1" />
  <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.0" PrivateAssets="All" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.0.0"/>

在我的一种列表方法中，我遇到了这个错误：

InvalidOperationException: A second operation started on this context before a previous operation completed. Any instance members are not guaranteed to be thread safe.
Microsoft.EntityFrameworkCore.Internal.ConcurrencyDetector.EnterCriticalSection()

这是我的方法：

    [HttpGet("{currentPage}/{pageSize}/")]
    [HttpGet("{currentPage}/{pageSize}/{search}")]
    public ListResponseVM<ClientVM> GetClients([FromRoute] int currentPage, int pageSize, string search)
    {
        var resp = new ListResponseVM<ClientVM>();
        var items = _context.Clients
            .Include(i => i.Contacts)
            .Include(i => i.Addresses)
            .Include("ClientObjectives.Objective")
            .Include(i => i.Urls)
            .Include(i => i.Users)
            .Where(p => string.IsNullOrEmpty(search) || p.CompanyName.Contains(search))
            .OrderBy(p => p.CompanyName)
            .ToPagedList(pageSize, currentPage);

        resp.NumberOfPages = items.TotalPage;

        foreach (var item in items)
        {
            var client = _mapper.Map<ClientVM>(item);

            client.Addresses = new List<AddressVM>();
            foreach (var addr in item.Addresses)
            {
                var address = _mapper.Map<AddressVM>(addr);
                address.CountryCode = addr.CountryId;
                client.Addresses.Add(address);
            }

            client.Contacts = item.Contacts.Select(p => _mapper.Map<ContactVM>(p)).ToList();
            client.Urls = item.Urls.Select(p => _mapper.Map<ClientUrlVM>(p)).ToList();
            client.Objectives = item.Objectives.Select(p => _mapper.Map<ObjectiveVM>(p)).ToList();
            resp.Items.Add(client);
        }

        return resp;
    }

我有点迷茫，尤其是当我在本地运行它时它可以工作，但是当我部署到我的登台服务器（IIS 8.5）时，它得到了这个错误并且它工作正常。在我增加其中一个模型的最大长度后，错误开始出现。我还更新了相应视图模型的最大长度。还有许多其他的列表方法非常相似，而且它们都在起作用。

我有一个 Hangfire 作业正在运行，但该作业不使用相同的实体。这就是我认为相关的所有内容。关于可能导致此问题的任何想法？

Answer 1

我不确定您是否使用 IoC 和依赖注入来解析 DbContext 可能会用到的地方。如果您这样做并且您正在使用来自 .NET Core（或任何其他 IoC 容器）的本机 IoC，并且您收到此错误，请确保将您的 DbContext 注册为 Transient。做

services.AddDbContext<MyContext>(ServiceLifetime.Transient);

或

services.AddTransient<MyContext>();

而不是

services.AddDbContext<MyContext>();

AddDbContext 将上下文添加为作用域，这在使用多个线程时可能会导致麻烦。

当使用异步 lambda 表达式时，async / await operations 也可能导致此行为。

将其添加为瞬态也有其缺点。您将无法通过使用上下文的多个类对某些实体进行更改，因为每个类都将获得自己的 DbContext 实例。

对此的简单解释是，DbContext 实现不是线程安全的。你可以阅读更多关于这个here

Answer 2

在某些情况下，调用没有await关键字的async方法会出现此错误，只需在方法调用前添加await即可解决。但是，答案可能与提到的问题无关，但它可以帮助解决类似的错误。

Answer 3

异常表示_context同时被两个线程使用；两个线程在同一个请求中，或者由两个请求。

您的_context 是否声明为静态？不应该。

或者您是否从代码中的其他位置在同一个请求中多次调用GetClients？

您可能已经这样做了，但理想情况下，您将使用 dependency injection 作为您的 DbContext，这意味着您将在 Startup.cs 中使用 AddDbContext()，并且您的控制器构造函数看起来会有所不同像这样：

private readonly MyDbContext _context; //not static

public MyController(MyDbContext context) {
    _context = context;
}

如果您的代码不是这样，请向我们展示，也许我们可以提供进一步帮助。

Answer 4

我遇到了同样的问题，结果发现 父服务是一个单例。所以上下文也自动变成了单例。尽管在 DI 中被声明为 Per Life Time Scoped。

将不同生命周期的服务注入另一个

1. 切勿将 Scoped & Transient 服务注入 Singleton 服务。 ( 这有效地将瞬态或范围服务转换为 单身人士。 )

2. 永远不要将瞬态服务注入作用域服务（这会将 临时服务进入作用域。 )

Answer 5

• 使用我的 Startup.cs 文件中的这行代码解决我的问题。
  添加临时服务意味着每次请求服务时，都会在您工作时创建一个新实例 和 依赖注入

         services.AddDbContext<Context>(options =>
                          options.UseSqlServer(_configuration.GetConnectionString("ContextConn")),
               ServiceLifetime.Transient);
  

Answer 6

我认为这个答案仍然可以帮助一些人并节省很多次。我通过将IQueryable 更改为List（或数组、集合...）解决了类似的问题。

例如：

var list = _context.table1.Where(...);

到

var list = _context.table1.Where(...).ToList(); //or ToArray()...

Answer 7

我有同样的错误。发生这种情况是因为我调用了一个构造为public async void ... 而不是public async Task ... 的方法。

Answer 8

Entity Framework Core 不支持在同一个 DbContext 实例上运行多个并行操作。这包括async 查询的并行执行和来自多个线程的任何显式并发使用。因此，请始终立即调用await async，或者为并行执行的操作使用单独的DbContext 实例。

Answer 9

我遇到了同样的问题，但原因不是上面列出的任何一个。我创建了一个任务，在任务内部创建了一个范围，并要求容器获取服务。这工作得很好，但后来我在任务中使用了第二个服务，我忘了也要求它到新的范围。因此，第二个服务使用了一个已经被释放的 DbContext。

Task task = Task.Run(() =>
    {
        using (var scope = serviceScopeFactory.CreateScope())
        {
            var otherOfferService = scope.ServiceProvider.GetService<IOfferService>();
            // everything was ok here. then I did: 
            productService.DoSomething(); // (from the main scope) and this failed because the db context associated to that service was already disposed.
            ...
        }
    }

我应该这样做：

var otherProductService = scope.ServiceProvider.GetService<IProductService>();
otherProductService.DoSomething();

Answer 10

我有一个后台服务，它为表中的每个条目执行一个操作。问题是，如果我在 DbContext 的同一实例上迭代并修改所有数据，则会发生此错误。

一个解决方案，正如这个线程中提到的，通过定义它来将 DbContext 的生命周期更改为瞬态

services.AddDbContext<DbContext>(ServiceLifetime.Transient);

但是因为我在多个不同的服务中进行了更改并使用SaveChanges() 方法一次提交它们，所以这个解决方案在我的情况下不起作用。

因为我的代码在服务中运行，所以我正在做类似的事情

using (var scope = Services.CreateScope())
{
   var entities = scope.ServiceProvider.GetRequiredService<IReadService>().GetEntities();
   var writeService = scope.ServiceProvider.GetRequiredService<IWriteService>();
   foreach (Entity entity in entities)
   {
       writeService.DoSomething(entity);
   } 
}

能够像使用简单请求一样使用服务。所以为了解决这个问题，我只是将单个范围分成两部分，一个用于查询，另一个用于写操作，如下所示：

using (var readScope = Services.CreateScope())
using (var writeScope = Services.CreateScope())
{
   var entities = readScope.ServiceProvider.GetRequiredService<IReadService>().GetEntities();
   var writeService = writeScope.ServiceProvider.GetRequiredService<IWriteService>();
   foreach (Entity entity in entities)
   {
       writeService.DoSomething(entity);
   } 
}

像这样，有效地使用了两个不同的 DbContext 实例。

另一种可能的解决方案是确保读取操作在开始迭代之前已终止。这在我的情况下不是很实用，因为可能有很多结果都需要加载到内存中以进行操作，而我首先尝试通过使用 Queryable 来避免。

Answer 11

如果您创建了迁移 (Add-Migration) 但忘记实际更新数据库 (Update-Database)，也可能会出现此错误。

Answer 12

有一些函数 Async 但你不要在它之前调用 await 。在调用该函数之前查找并添加 await 将对您有所帮助。

Answer 13

我知道两年前有人问过这个问题，但我刚遇到这个问题，我使用的修复程序确实有帮助。

如果您使用相同的上下文执行两个查询 - 您可能需要删除 AsNoTracking。如果您确实使用AsNoTracking，您将为每次读取创建一个新的数据读取器。两个数据读取器不能读取相同的数据。

Answer 14

我收到了同样的信息。但这对我来说没有任何意义。我的问题是我错误地使用了“NotMapped”属性。 在某些情况下，它可能仅意味着 Linq 语法或模型类的错误。错误消息似乎具有误导性。这条消息的原意是你不能在同一个请求中对同一个 dbcontext 多次调用 async。

[NotMapped]
public int PostId { get; set; }
public virtual Post Post { get; set; }

您可以查看此链接了解详细信息， https://www.softwareblogs.com/Posts/Details/5/error-a-second-operation-started-on-this-context-before-a-previous-operation-completed

Answer 15

当我尝试在下面代码的异步方法中使用FirstOrDefaultAsync() 时遇到了同样的问题。当我修复FirstOrDefault() 时，问题就解决了！

_context.Issues.Add(issue);
        await _context.SaveChangesAsync();

        int userId = _context.Users
            .Where(u => u.UserName == Options.UserName)
            .FirstOrDefaultAsync()
            .Id;
...

Answer 16

我通过将IQueryable 传递给一个方法，然后将该 IQueryable“列表”用作对同一上下文的另一个查询的一部分，设法得到了该错误。

public void FirstMethod()
{
    // This is returning an IQueryable
    var stockItems = _dbContext.StockItems
        .Where(st => st.IsSomething);

    SecondMethod(stockItems);
}

public void SecondMethod(IEnumerable<Stock> stockItems)
{
    var grnTrans = _dbContext.InvoiceLines
        .Where(il => stockItems.Contains(il.StockItem))
        .ToList();
}

为了阻止这种情况发生，我使用了approach here 并在传递第二种方法之前将该列表具体化，方法是将对SecondMethod 的调用更改为SecondMethod(stockItems.ToList()

Answer 17

我的情况不同： 我试图用 30 个属于特定角色的用户为数据库播种，所以我运行了以下代码：

for (var i = 1; i <= 30; i++)
{
    CreateUserWithRole("Analyst", $"analyst{i}", UserManager);
}

这是一个同步功能。 在里面我有 3 个电话：

UserManager.FindByNameAsync(username).Result
UserManager.CreateAsync(user, pass).Result
UserManager.AddToRoleAsync(user, roleName).Result

当我用.GetAwaiter().GetResult() 替换.Result 时，这个错误就消失了。

Answer 18

首先，（至少）支持 alsami 的回答。这让我走上了正确的道路。

但对于那些从事 IoC 的人来说，这里有一点更深入的了解。

我的错误（和其他人一样）

发生了一个或多个错误。 （第二次手术开始于这个 前一个操作完成之前的上下文。这通常是由于 由不同的线程使用相同的 DbContext 实例。更多 有关如何避免 DbContext 线程问题的信息，请参阅 https://go.microsoft.com/fwlink/?linkid=2097913.)

我的代码设置。 “只是基础”...

public class MyCoolDbContext: DbContext{
    public DbSet <MySpecialObject> MySpecialObjects {        get;        set;    }
}

和

public interface IMySpecialObjectDomainData{}

并且（注意 MyCoolDbContext 正在被注入）

public class MySpecialObjectEntityFrameworkDomainDataLayer: IMySpecialObjectDomainData{
    public MySpecialObjectEntityFrameworkDomainDataLayer(MyCoolDbContext context) {
        /* HERE IS WHERE TO SET THE BREAK POINT, HOW MANY TIMES IS THIS RUNNING??? */
        this.entityDbContext = context ?? throw new ArgumentNullException("MyCoolDbContext is null", (Exception)null);
    }
}

和

public interface IMySpecialObjectManager{}

和

public class MySpecialObjectManager: IMySpecialObjectManager
{
    public const string ErrorMessageIMySpecialObjectDomainDataIsNull = "IMySpecialObjectDomainData is null";
    private readonly IMySpecialObjectDomainData mySpecialObjectDomainData;

    public MySpecialObjectManager(IMySpecialObjectDomainData mySpecialObjectDomainData) {
        this.mySpecialObjectDomainData = mySpecialObjectDomainData ?? throw new ArgumentNullException(ErrorMessageIMySpecialObjectDomainDataIsNull, (Exception)null);
    }
}

最后，我的多线程类，从控制台应用程序（命令行界面应用程序）调用

    public interface IMySpecialObjectThatSpawnsThreads{}

和

public class MySpecialObjectThatSpawnsThreads: IMySpecialObjectThatSpawnsThreads
{
    public const string ErrorMessageIMySpecialObjectManagerIsNull = "IMySpecialObjectManager is null";

    private readonly IMySpecialObjectManager mySpecialObjectManager;

    public MySpecialObjectThatSpawnsThreads(IMySpecialObjectManager mySpecialObjectManager) {
        this.mySpecialObjectManager = mySpecialObjectManager ?? throw new ArgumentNullException(ErrorMessageIMySpecialObjectManagerIsNull, (Exception)null);
    }
}

和 DI 积累。 （同样，这是针对控制台应用程序（命令行界面）...其行为与 Web 应用程序略有不同）

private static IServiceProvider BuildDi(IConfiguration configuration) {
    /* this is being called early inside my command line application ("console application") */

    string defaultConnectionStringValue = string.Empty; /* get this value from configuration */

    ////setup our DI
    IServiceCollection servColl = new ServiceCollection()
        ////.AddLogging(loggingBuilder => loggingBuilder.AddConsole())

        /* THE BELOW TWO ARE THE ONES THAT TRIPPED ME UP.  */
        .AddTransient<IMySpecialObjectDomainData, MySpecialObjectEntityFrameworkDomainDataLayer>()
    .AddTransient<IMySpecialObjectManager, MySpecialObjectManager>()

    /* so the "ServiceLifetime.Transient" below................is what you will find most commonly on the internet search results */
     # if (MY_ORACLE)
        .AddDbContext<ProvisioningDbContext>(options => options.UseOracle(defaultConnectionStringValue), ServiceLifetime.Transient);
     # endif

     # if (MY_SQL_SERVER)
        .AddDbContext<ProvisioningDbContext>(options => options.UseSqlServer(defaultConnectionStringValue), ServiceLifetime.Transient);
     # endif

    servColl.AddSingleton <IMySpecialObjectThatSpawnsThreads,        MySpecialObjectThatSpawnsThreads>();

    ServiceProvider servProv = servColl.BuildServiceProvider();

    return servProv;
}

让我感到惊讶的是（更改为）瞬态

        .AddTransient<IMySpecialObjectDomainData, MySpecialObjectEntityFrameworkDomainDataLayer>()
    .AddTransient<IMySpecialObjectManager, MySpecialObjectManager>()

注意，我认为因为 IMySpecialObjectManager 被注入到“MySpecialObjectThatSpawnsThreads”中，所以那些注入的对象需要是瞬态的才能完成链。

重点是....... 需要 .Transient 的不仅仅是 (My)DbContext...而是更大的 DI 图表块。

调试提示：

这一行：

this.entityDbContext = context ?? throw new ArgumentNullException("MyCoolDbContext is null", (Exception)null);

把你的调试器断点放在那里。如果您的 MySpecialObjectThatSpawnsThreads 正在创建 N 个线程（例如 10 个线程）......并且该行只被击中一次......那是你的问题。您的 DbContext 正在跨线程。

奖金：

我建议阅读下面的 url/article（oldie but goodie），了解 web-apps 和 console-apps 的区别

https://mehdi.me/ambient-dbcontext-in-ef6/

这是文章的标题，以防链接更改。

使用实体框架 6 以正确的方式管理 DBCONTEXT：深入探讨 指南 Mehdi El Gueddari

我用 WorkFlowCore https://github.com/danielgerlag/workflow-core 解决了这个问题

  <ItemGroup>
    <PackageReference Include="WorkflowCore" Version="3.1.5" />
  </ItemGroup>

下面的示例代码.. 以帮助未来的互联网搜索者

 namespace MyCompany.Proofs.WorkFlowCoreProof.BusinessLayer.Workflows.MySpecialObjectInterview.Workflows
    {
        using System;
        using MyCompany.Proofs.WorkFlowCoreProof.BusinessLayer.Workflows.MySpecialObjectInterview.Constants;
        using MyCompany.Proofs.WorkFlowCoreProof.BusinessLayer.Workflows.MySpecialObjectInterview.Glue;
        using MyCompany.Proofs.WorkFlowCoreProof.BusinessLayer.Workflows.WorkflowSteps;

        using WorkflowCore.Interface;
        using WorkflowCore.Models;

        public class MySpecialObjectInterviewDefaultWorkflow : IWorkflow<MySpecialObjectInterviewPassThroughData>
        {
            public const string WorkFlowId = "MySpecialObjectInterviewWorkflowId";

            public const int WorkFlowVersion = 1;

            public string Id => WorkFlowId;

            public int Version => WorkFlowVersion;

            public void Build(IWorkflowBuilder<MySpecialObjectInterviewPassThroughData> builder)
            {
                builder
                             .StartWith(context =>
                    {
                        Console.WriteLine("Starting workflow...");
                        return ExecutionResult.Next();
                    })

                        /* bunch of other Steps here that were using IMySpecialObjectManager.. here is where my DbContext was getting cross-threaded */


                    .Then(lastContext =>
                    {
                        Console.WriteLine();

                        bool wroteConcreteMsg = false;
                        if (null != lastContext && null != lastContext.Workflow && null != lastContext.Workflow.Data)
                        {
                            MySpecialObjectInterviewPassThroughData castItem = lastContext.Workflow.Data as MySpecialObjectInterviewPassThroughData;
                            if (null != castItem)
                            {
                                Console.WriteLine("MySpecialObjectInterviewDefaultWorkflow complete :)  {0}   -> {1}", castItem.PropertyOne, castItem.PropertyTwo);
                                wroteConcreteMsg = true;
                            }
                        }

                        if (!wroteConcreteMsg)
                        {
                            Console.WriteLine("MySpecialObjectInterviewDefaultWorkflow complete (.Data did not cast)");
                        }

                        return ExecutionResult.Next();
                    }))

                    .OnError(WorkflowCore.Models.WorkflowErrorHandling.Retry, TimeSpan.FromSeconds(60));

            }
        }
    }

和

ICollection<string> workFlowGeneratedIds = new List<string>();
                for (int i = 0; i < 10; i++)
                {
                    MySpecialObjectInterviewPassThroughData currentMySpecialObjectInterviewPassThroughData = new MySpecialObjectInterviewPassThroughData();
                    currentMySpecialObjectInterviewPassThroughData.MySpecialObjectInterviewPassThroughDataSurrogateKey = i;

                    ////  private readonly IWorkflowHost workflowHost;
                    string wfid = await this.workflowHost.StartWorkflow(MySpecialObjectInterviewDefaultWorkflow.WorkFlowId, MySpecialObjectInterviewDefaultWorkflow.WorkFlowVersion, currentMySpecialObjectInterviewPassThroughData);
                    workFlowGeneratedIds.Add(wfid);
                }

Answer 19

在我的例子中，我在 Blazor 中使用模板组件。

 <BTable ID="Table1" TotalRows="MyList.Count()">

问题是在组件头中调用了一个方法（Count）。 为了解决这个问题，我改变了它：

int total = MyList.Count();

及以后：

<BTable ID="Table1" TotalRows="total">

Answer 20

我之前遇到过这个问题。问题是异步/等待操作。我做了一个异步函数。此函数在运行时设置数据库的连接字符串。我做了这个函数异步函数。所以，我去掉了这个函数的 async/await 操作，问题就解决了。 使数据库瞬态可以解决问题，但如果您需要更新数据库中许多表的数据，那就不好了。

Answer 21

这发生在我身上。 因为方法是异步的，所以我用 await 问题解决了。

Answer 22

为这个错误添加另一个可能的解决方案，以防它帮助某人。

在我的情况下，问题是在查询中使用导航属性，如下所示：

var selectedOrder = dbContext.Orders.Where(x => x.Id == id).Single();
var relatedOrders = dbContext.Orders.Where(x => x.User.Id == selectedOrder.User.Id).ToList();

问题是在查询中使用 selectedOrder.User.Id。如果尚未加载 User nav 属性，EF 将尝试在尝试执行查询的过程中延迟加载该属性，它认为这是在尝试启动第二个操作。解决方案是为 selectedOrder.User.Id 创建一个单独的变量，以确保在查询开始之前加载查询所需的信息：

var selectedOrder = dbContext.Orders.Where(x => x.Id == id).Single();
var userId = selectedOrder.User.Id;
var relatedOrders = dbContext.Orders.Where(x => x.User.Id == userId).ToList();

Answer 23

在我的情况下，我使用的锁不允许使用 await，并且当您不等待异步时不会创建编译器警告。

问题：

lock (someLockObject) {
    // do stuff
    context.SaveChangesAsync();
}

// some other code somewhere else doing await context.SaveChangesAsync() shortly after the lock gets the concurrency error

修复： 通过使用 .Wait() 阻塞来等待锁内的异步

lock (someLockObject) {
    // do stuff
    context.SaveChangesAsync().Wait();
}

Answer 24

另一种可能的情况：如果直接使用连接，不要忘记关闭 if。我需要执行任意 SQL 查询，并读取结果。这是一个快速修复，我不想定义数据类，也不想设置“正常”SQL 连接。所以很简单，我将 EFC 的数据库连接重用为var connection = Context.Database.GetDbConnection() as SqlConnection。确保在拨打Context.SaveChanges() 之前拨打connection.Close()。

Answer 25

我尝试了上述所有解决方案，但没有一个对我运行代码的方式有帮助。然后 在使用 this._context... 之前添加 Task.Delay(300).Wait(); 解决了这个问题，因为它在访问上下文之前等待 300 毫秒，从而允许完成之前的操作。

最终代码如下所示

Task.Delay(300).Wait();
response.Item = await this._context.Users
                 .Where(x => x.Username.ToLower().Equals(email))
                 .FirstOrDefaultAsync(); 

Answer 26

如果你的方法返回了一些东西，你可以通过把 .Result 到工作结束和 .Wait() 如果它没有返回任何东西。

Answer 27

您可以使用 SemaphoreSlim 阻止将尝试执行该 EF 调用的下一个线程。

static SemaphoreSlim semSlim = new SemaphoreSlim(1, 1);

await semSlim.WaitAsync();
try
{
  // something like this here...
  // EmployeeService.GetList(); or...
  var result = await _ctx.Employees.ToListAsync();
}
finally
{
  semSlim.Release();
}

Answer 28

我只是设法让它再次工作。这没有多大意义，但确实有效：

1. 从 StartUp 中删除 Hangfire（我正在那里创建工作）
2. 已删除hangfire 数据库
3. 重新启动服务器

稍后我会进一步调查，但我使用 hangfire 调用的方法收到了 DBContext，这就是可能的原因。