EF6: saving to same entity using dbContext in async tasks

Question

I load an object/entity from the database:

var db = new DbContext();

//...

var item = db.Items.First();

Then I want to perform two asynchronous tasks, that when returned, update data on the item:

var task1 = Function1(db, item); 
var task2 = Function2(db, item); 
await Task.WhenAll(new Task[] { task1 , task2 });

The two functions will have some code that gets, sets & saves a (different) property on the item, like so:

var orderId = await CallApi();
item.OrderId = orderId;
db.Entry(item).State = EntityState.Modified;
await db.SaveChangesAsync();

However, as they are running asynchonously, I'm getting the error: A second operation started on this context before a previous asynchronous operation completed.

I tried newing up a dbContext in the Functions, but then I get the error An entity object cannot be referenced by multiple instances of IEntityChangeTracker.

I understand why I'm getting both of these errors, my question is: what coding pattern would best resolve this?

EDIT Ok, so the above was a simplified example. In reality, there is a lot more work that goes on in the functions, so it would be difficult to move all that logic out of the function and into the calling method. I also want that all that work to be self-contained.

The properties on the item that Function1 and Function2 update are discrete. I'm using this library to ensure that the save doesn't overwrite all the fields.

You can move the code db.Entry(item).State = EntityState.Modified; await db.SaveChangesAsync(); after the Task.whenall(). The job of those 2 functions is to update the properties of that object. — Sree Harsha Nellore
– Sree Harsha Nellore, Commented Jul 27, 2018 at 10:30
You can't share dbcontext between task... Create one for each task — Dani
– Dani, Commented Jul 27, 2018 at 10:32
I don't think it makes much sense to update the same database record in parallel tasks. What do you think to gain by that? — Gert Arnold
– Gert Arnold, Commented Jul 27, 2018 at 10:32
Also, by marking the entire item as modified each task will update all of its properties and the task that happens to be the last wins, erasing all changes from the other tasks. — Gert Arnold
– Gert Arnold, Commented Jul 27, 2018 at 10:36

demo · Accepted Answer · 2019-04-15 15:17:17Z

1

You can move the code

db.Entry(item).State = EntityState.Modified; 
await db.SaveChangesAsync();

after the Task.Whenall(). The job of those 2 functions is to update the properties of that object.

edited Apr 15, 2019 at 15:17

demo

6,29519 gold badges84 silver badges162 bronze badges

answered Jul 27, 2018 at 10:36

Sree Harsha Nellore

4385 silver badges12 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Panagiotis Kanavos Over a year ago

What's the point? That's the same as not doing anything in parallel and calling await db.SaveChangesAsync() once at the end. Which, btw, is what the OP should have done in the first place

Panagiotis Kanavos Over a year ago

That's not obvious from the answer as it is now

Sean Over a year ago

That's so simple - not sure why I didn't see it! A small concern is that I want the values from the Api calls saved to the database ASAP, where this option would only save when both calls complete. I'll give this a try, though.

Harald Coppoolse · Accepted Answer · 2018-08-20 14:35:27Z

Don't let two threads perform operations on the same dbContext. A dbContext keeps track of the fetched items. If two threads are fetching and changing items on the same DbContext at the same time, it might lead to undesired results.

Furthermore: if you fetched an Item, just change the properties you want. You don't need to set the state to Modified. A dbContext can check whether it has the original value or not.

So create functions that create their own DbContext, Fetch the requested data, change the data, save the data and finally Dispose the dbContext.

async Task Function1(...)
{
    using (var dbcontext = new MyDbContext(...))
    {
        // Start Fetching the item that must be changed; don't await yet
        var taskFetchItemToChange = dbContext.Items
            .Where(...)
            .FirstOrDefaultAsync();

        // Start fetching the orderId that must be changed; don't await yet
        var taskFetchOrderId = this.CallApiAsync();

        // await until both item and orderId are fetched:
        await Task.WhenAll(new Task[] {taskFetchItemToChange, taskFetchOrderId});

        var fetchedItemToChange = taskFetchItemToChange.Result;
        var fetchedOrderId = taskFetchOrderId.Result;
        fetchedItemToChange.OrderId = fetchedOrderId;
        // or do this in one big unreadable unmaintainable untestable step

        await dbContext.SaveChangesAsync();
    }
}

You will have a similar Function2, or maybe the same Function1 with different parameters.

var taskFunction1 = Function1();
var taskFunction2 = Function2();
await Task.WhenAll( new Task[] {taskFunction1, taskFunction2});

Thanks for your answer. My concern about this approach is that the code runs in a loop many times in a second. Optimising the code performance was important. So I didn't want to new up a dbContext / fetch data every time. I should have mentioned that up front.

Collectives™ on Stack Overflow

EF6: saving to same entity using dbContext in async tasks

2 Answers 2

3 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related