Entity Framework disposing with async controllers in Web api/MVC

Question

I have this little sample of code:

public class ValueController : ApiController
{
    private EstateContext _db;

    public ValueController()
    {
        _db = new EstateContext();
    }

    [HttpPost]
    public async void DoStuff(string id)
    {
        var entity = await _db.Estates.FindAsync(id); //now our method goes out and Dispose method is calling
        //returns here after disposing
        _db.SaveChanges(); // _db is disposed

    }

    protected override void Dispose(bool disposing)
    {
        base.Dispose(disposing);
        _db.Dispose();
    }
}

Every ApiController/Controller implements IDisposable interface. So in the Dispose method I want to free up any resources such as DbContext. But if async is used, this Dispose method calls at first occurrence of await. So after await I have DbContext already disposed. So what is the best way to dispose EF Contexts when async is used? It turns out that it is not possible to rely on Dispose method in controller?

async void? That seems like a bad idea...

David
– David

2016-03-14 12:59:57 +00:00
Commented Mar 14, 2016 at 12:59 — David
– David, Commented Mar 14, 2016 at 12:59
@David you saved me a lot of time by the way)) thank you

Wachburn
– Wachburn

2016-03-14 13:05:31 +00:00
Commented Mar 14, 2016 at 13:05 — Wachburn
– Wachburn, Commented Mar 14, 2016 at 13:05

Community · Accepted Answer · 2017-05-23 10:30:48Z

13

But if async is used, this Dispose method calls at first occurrence of await.

@Konstantins answer is correct, but allow me to elaborate a bit on why that happens. When you use an async void method, you're basically creating a "fire and forget" semantics to your method call, because any caller of this method can't itself asynchronously wait on it with await, as it returns void and not a form of an awaitable (such as a Task).

Thus, although WebAPI does support asynchronous methods, when invoking your action it seems as if it was a synchronous void returning method, and then the ASP.NET runtime goes on to dispose your controller, because it assumes that you're done with the action.

When exposing a Task or Task<T>, you're explicitly telling the caller "Listen, this method is asynchronous an will eventually return a value in the future". The ASP.NET runtime knows your controller hasn't finished invoking his action, and awaits upon the actual completion of the action.

This is why a call like this:

[HttpPost]
public async Task DoStuffAsync(string id)
{
    var entity = await _db.Estates.FindAsync(id);
    _db.SaveChanges(); 
}

Works.

As a side note - EF DbContext are meant to be used and disposed as soon as possible. Using them as a global variable for multiple actions is a bad idea, as they are not thread-safe either. I would suggest a different pattern where each action initializes and disposes the DbContext:

[HttpPost]
public async Task DoStuffAsync(string id)
{
    using (var db = new EstateContext())
    {
        var entity = await db.Estates.FindAsync(id);
        db.SaveChanges(); 
    }
}

As pointed out by @Wachburn in the comments, this approach is indeed less testable. If you ensure that your controller and action are disposed after each action is complete and there's no re-use of the context, you're safe to inject the DbContext via a DI container.

edited May 23, 2017 at 10:30

CommunityBot

11 silver badge

answered Mar 14, 2016 at 13:08

Yuval Itzchakov

150k32 gold badges275 silver badges333 bronze badges

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

3 Comments

Wachburn Over a year ago

thanks for detailed explanation. But on the second part - what about injection and unit testing? how to test such a controllers and actions if I can't setup context?

Yuval Itzchakov Over a year ago

@Wachburn You're right, it's less testable. If you ensure that your controller is disposed after each method call and there's no re-use of the same context between actions, then you're safe with using the approach that uses a DI container to inject the right dependency.

Tobi Owolawi Over a year ago

my main method is not an action and the return type is not void but task, but the DB context is still getting disposed..... but i am using the DBContext in a catch statement, could this be the reason?

Konstantin Dinev · Accepted Answer · 2016-03-14 13:23:40Z

3

You need to create a new instance of your EstateContext inside the async method.

[HttpPost]
public async void DoStuff(string id)
{
    EstateContext db = new EstateContext();
    var entity = await db.Estates.FindAsync(id);
    db.SaveChanges();
}

However, I believe that if you change the return type of your controller action to Task<ActionResult> then you should be able to reuse the context that is a member of the controller.

[HttpPost]
public async Task<ActionResult> DoStuff(string id)
{
    var entity = await _db.Estates.FindAsync(id);
    _db.SaveChanges();
}

edited Mar 14, 2016 at 13:23

answered Mar 14, 2016 at 12:57

Konstantin Dinev

35k14 gold badges79 silver badges102 bronze badges

Collectives™ on Stack Overflow

Entity Framework disposing with async controllers in Web api/MVC

2 Answers 2

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related