I am currently working a bug related to implementing GraphQL in a .NET Core application. I am using HotChocolate.AspNetCore as the GraphQL server library. I am trying to implement a simple query that returns a list of contacts. When I’ve tested the query to return a contact list the first time, I get a proper response.

query {
  all {
    id
    name
    email
  }
}

When I invoke the query again, I receive the following error:

Cannot access a disposed context instance. A common cause of this error is disposing a context instance that was resolved from dependency injection and then later trying to use the same context instance elsewhere in your application. This may occur if you are calling ‘Dispose’ on the context instance, or wrapping it in a using statement. If you are using dependency injection, you should let the dependency injection container take care of disposing context instances

I have reviewed the following posts to resolve the issue:

• Why is my context disposed before I can use it?

Libraries currently used

• HotChocolate.AspNetCore – 13.9.6
• HotChocolate.Data.EntityFramework – 13.9.6
• Using DotNet Core 7.0

ContactsGQLRepository

public class ContactsGQLRepository : IContactGQLRepository
{
    private readonly ContactContext _context;

    public ContactsGQLRepository(ContactContext context)
    {
        _context = context;
    }

    public async Task<Contact?> GetAsync(Guid id, CancellationToken cancel)
    {
        return await _context.Contacts.SingleOrDefaultAsync(x => x.Id == id, cancel);
    }

    public IQueryable<Contact> GetAll()
    {        
        var response = _context.Contacts;
        return response;
    }

    public IQueryable<Contact> GetWithFilter(Expression<Func<Contact, bool>> filter)
    {
        return _context.Contacts.Where(filter);
    }

}

ContactsEndpoint

public static class ContactsEndpoint
{
    public static void AddEnpoints(this IEndpointRouteBuilder app)
    {
        app.MapGet("/Contacts", async ([Service(ServiceKind.Synchronized)] IContactGQLRepository contactGQLRepository) =>
        {
            return contactGQLRepository.GetAll();
        });
    }
}

ContactsQuery

public class ContactsQuery
{
    private readonly IContactGQLRepository repository;

    public ContactsQuery([Service(ServiceKind.Synchronized)] IContactGQLRepository repository)
    {
        this.repository = repository;
    }

    /// <summary>
    /// Plane Get with GraphQL without filtering
    /// </summary>
    /// <returns></returns>
    public async Task<IQueryable<Contact>> GetAll()
    {
        return repository.GetAll();
    }

    /// <summary>
    /// Get with filters and paging
    /// </summary>
    /// <returns></returns>
    [UsePaging(IncludeTotalCount = true, DefaultPageSize = 50)]
    [UseFiltering]
    public async Task<IQueryable<Contact>> GetContacts()
    {
        return repository.GetWithFilter(default);
    }
}

Setting up dependency injection in Program.cs

// add graphQL services
builder.Services
        .AddScoped(typeof(IContactsGQLRepository), typeof(ContactsGQLRepository))
        .AddGraphQLServer()
        .RegisterDbContext<ContactsContext>(DbContextKind.Synchronized)
        .AddQueryType<ContactsQuery>()
        .AddFiltering()
        .ModifyRequestOptions(opt => opt.IncludeExceptionDetails = builder.Environment.IsDevelopment());


builder.Services.AddEndpointsApiExplorer();

// other code 

app.UseRouting();
app.MapGraphQL();

var rider = app.MapGroup("/v1/contacts");
rider.AddEnpoints();

Build out a query

public class ContactsQuery
{
    private readonly IContactsGQLRepository repository;

    public ContactsQuery([Service(ServiceKind.Synchronized)] IContactsGQLRepository repository)
    {
        this.repository = repository;
    }

    /// <summary>
    /// Plane Get with GraphQL without filtering
    /// </summary>
    /// <returns></returns>
    public async Task<IQueryable<Contact>> GetAll()
    {
        return repository.GetAll();
    }

    /// <summary>
    /// Get with filters and paging
    /// </summary>
    /// <returns></returns>
    [UsePaging(IncludeTotalCount = true, DefaultPageSize = 50)]
    [UseFiltering]
    public async Task<IQueryable<Contact>> GetContacts()
    {
        return repository.GetWithFilter(default);
    }
}