Is it safe to call SaveChanges within an async foreach loop on a DbSet in EF Core?

When you’re streaming results with an async enumerable, the active asynchronous iteration is considered an in‐flight operation on the context. That means while the enumeration is still in progress (i.e. the data reader is open and pumping results via each MoveNextAsync), you cannot execute another command such as SaveChanges on the same DbContext instance.

In your sample code the SaveChangesAsync call happens inside the body of the async foreach loop on the same context. Because the enumerator is still “active” (holding an open connection, etc.), calling SaveChanges will trigger the "multiple active operations" error.

Options to work around this include:

• Use a Separate Context: Continue using one context for the query (the async enumerable) and a different context instance for updates. This avoids overlapping operations on the same context.

• Buffer the Data: If feasible, materialize the query results (for example using ToListAsync) so that all the data is loaded first. Once the enumeration is complete, you can iterate over the in‑memory collection and update in the same context.

For example, using a separate context:

CSHARPCopied
await foreach (var o in db.Orders
                          .Where(o => o.Status != 1)
                          .AsAsyncEnumerable()
                          .WithCancellation(cancellationToken)
                          .ConfigureAwait(false))
{
    // Mark the order
    o.Status = 1;

    // Create a new scope/DbContext for the update
    await using var updateScope = serviceScopeFactory.CreateAsyncScope();
    var updateDb = updateScope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
    
    // Attach or update the entry in the new context and save changes.
    updateDb.Orders.Attach(o);
    updateDb.Entry(o).Property(x => x.Status).IsModified = true;
    await updateDb.SaveChangesAsync(cancellationToken);
    
    // Run fire-and-forget async work once
}

By separating your reading and saving operations across different DbContext instances, you adhere to the requirement that a single context instance must not have multiple active operations concurrently.

Remember, the async enumerable is treated as an in‑flight operation, so while it’s active you cannot issue a new command on that same DbContext without risking runtime errors.