System.InvalidOperationException: 'Invalid operation. The connection is closed.'

Question

I am using .net core 6.0. I am getting this error when I am calling the same method from different places. I tried calling this method GetEmployeeByEmployeeNumber from inside `Index and I dont get any error and the method returns the object employee with value values populated in employee

public async Task<IActionResult> Index()
{
   EmployeeInfo employee =  await _employeeService.GetEmployeeByEmployeeNumber(up.EmployeeId); 
    PopulatePDFDoc();
    return View();
}

public async Task<EmployeeInfo?> GetEmployeeByEmployeeNumber(string employeeId)
{
    List<int> emplyoeeInfoId = new List<int>();
    UserPrincipal up = utilities.UserADIdentity.GetADUserInfo(WindowsIdentity.GetCurrent().Name.ToString());

    emplyoeeInfoId = _ackContext.EmployeeInfos.Where(e => e.EmployeeNumber == employeeId).OrderBy(e => e.DateFormFilled).Select(e => e.EmployeeInfoId).ToList();

    var employee = await _ackContext.EmployeeInfos.Include(e => e.EmergencyInfos.Where(p => p.EmployeeInfoId.Equals(emplyoeeInfoId.LastOrDefault()))).Where(e=>e.EmployeeInfoId.Equals(emplyoeeInfoId.LastOrDefault())).FirstOrDefaultAsync();
    return employee;
}

If I call the same method GetEmployeeByEmployeeNumber from inside PopulatePDFDoc(); then I get an error saying System.InvalidOperationException: 'Invalid operation. The connection is closed.'

below is my PopulatePDFDoc

public  async void PopulatePDFDoc()
{
    AckPackage.Data.PDFPopulate.DocPDF doc = new Data.PDFPopulate.DocPDF();
    EmployeeInfo employee =  await _employeeService.GetEmployeeByEmployeeNumber(up.EmployeeId);
}

below is the screen shot of the error: I am new to .net core. Any help on this will be highly appreciated.

Foreyard

Answer 1

You need to await the call to PopulatePDFDoc() inside the Index method.

Like this:

await PopulatePDFDoc();

Always use await when calling an async method!

The reason you’re getting a “connection closed” error, is because the database context _ackContext is getting disposed before the async method PopulatePDFDoc() gets a chance to finish. You need to "wait" for PopulatePDFDoc() to finish before allowing the request code to continue on.

ASP.NET automatically disposes scoped Entity Framework context services when the request finishes processing, so make sure you put the "await" keyword before any asynchronous method call that uses an Entity Framework scoped service (in your case, the _ackContext).

Also, PopulatePDFDoc() should return Task instead of void, like this:

public async Task PopulatePDFDoc()

Jareb

Answer 2

Another thing I noticed that may cause you issues is your _ackContext which looks like it's a class-wide member variable based on the snippet you shared, meaning that same context-instance is shared between multiple methods. However the context itself is actually not "thread safe", as can be read in Microsofts documentation here: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/working-with-dbcontext which means that if multiple async methods use the same context - which they do in your example - you may run into issues.

The recommended approach is to create the context when you need it, and use the using syntax to make sure it's disposed properly after your work is finished. Like this:

using (var ackContext = new EmployeeContext())
{     
    // Perform data access using the context here
}

Try using that in your GetEmployeeByEmployeeNumber method and see if it helps as well :)

Chaparro

It's not entirely accurate to say that the simple act of multiple async methods using the same context may cause thread issues, because async methods do not always run on separate threads. As long as you "await" each async method call, you don't need to worry about thread issues, because operations performed on the context will be performed in the order that you call the async methods. However, if the async methods are NOT awaited, then you may run into issues. – Jareb

Lastly, the original poster's code is very clearly a simple MVC controller (hence the "Index" method returning an IActionResult), so it's not necessary to put the context in a "using" statement, since the context was probably dependency-injected into the controller's constructor (and will get properly disposed of at the end of the request as all scoped services do). – Jareb

Answer 3

I received the same error message when I was opening the connection synchronously and executing queries asynchronously. The solution was to open the connection asynchronously as well.

Drawer

Answer 4

I know OP is using EF DbContext, but I came here facing a similar issue using NHibernate 5+. Since OP did not specify EF tag, I'll share my two cents on this as well.

This piece of code throws the same error (sometimes also masked as a NullReferenceException under the hood):

 private Task<SomeEntity> GetSomething(CancellationToken cancellationToken)
 {
     using var scope = _scopeFactory.NewScope();
     return scope.Query<SomeEntity>().FirstOrDefaultAsync(cancellationToken);
 }

In this case, scope gets disposed before querying occurs, so the fix is the same - await the call that uses IDisposable resource:

 private async Task<SomeEntity> GetSomething(CancellationToken cancellationToken)
 {
     using var scope = _scopeFactory.NewScope();

     // Await all calls that use the scope!
     return await scope.Query<SomeEntity>().FirstOrDefaultAsync(cancellationToken);
 }

In my case, caller is also awaiting GetSomething, so passing the scope as a parameter (instead of creating it inside GetSomething) would work too, since the caller would be the one owning the IDisposable resource. In this scenario, returning a task directly would be fine too.

Degrading