隔离EF Core中的更改

Question

Here's how I add the the DbContext service in ASP.NET Core Startup:

services.AddDbContextPool<AppDbContext>(options =>
            options.UseMySql(Configuration.GetConnectionString("DefaultConnection")));

services.AddScoped<ClassA, ClassA>();
services.AddScoped<ClassB, ClassB>();

ClassA - Method1

_dbContext.EntityX.Add(new EntityX { ... });

var product = ClassB.GetProduct(key);

_dbContext.EntityY.Add(new EntityY { Product = product });

_dbContext.SaveChanges();

ClassB - GetProduct

//Check product if it exists in the database
//Else, get details of the product from a Web API

var newProduct = new Product{ ... }
_dbContext.Products.Add(newProduct );

_dbContext.SaveChanges();

return newProduct;

I'll be honest and tell you I haven't tried running this yet, these codes are stripped (heavily) down version of the real code for brevity.

My questions are:

1) Do I have the same DbContext in both ClassA and ClassB ? Is that guaranteed?

2) If both ClassA and ClassB have the same DbContext , will the SaveChanges in ClassB affects the EntityX I added in ClassA ?

3) What should I do to isolate changes in ClassA and ClassB ?

Answer 1

Do I have the same DbContext in both ClassA and ClassB ? Is that guaranteed?

The database context are registered as scoped dependencies, that means that the instance is shared during the handling of a single incoming request. Every request will get its own dependency injection scope, so within a single request, you are guaranteed to get the same database context instance.

On the other hand, you are also guaranteed to get individual database contexts for separate requests.

If both ClassA and ClassB have the same DbContext , will the SaveChanges in ClassB affect the EntityX I added in ClassA ?

The short answer to that is yes. Since it's a single database context, there is also a single collection of entities that are being tracked. So if you ran ClassA.Method1 first and did not have a SaveChanges call there, and then ran ClassB.Method2 , the SaveChanges() in the latter would also save the changes from the first method.

While this may sound problematic, in practice it usually is not: A request is typically handled as part of a controller action, so there is a very clear control flow. As such, there isn't any parallel processing, and as long as you always “clean up” the context after using it (eg by calling SaveChanges() ) there will be no problem.

On the opposite hand, you can also use this to your advantage and share transactions throughout the handling of your request without your methods knowing that they are part of a transaction.

What should I do to isolate changes in ClassA and ClassB ?

Think about whether you actually need isolation. The only way your Method2 could impact Method1 is when Method1 performed changes to entities that are not saved. And if you are doing that, then you are likely misusing your entities anyway. Usually, a method should complete its work on entities, without leaving a dirty state behind.