Minimal Api: Best practices to prevent ApplicationDbContext from getting disposed to early?

[Gu4ty]

Noob here. I am implementing a simple edit endpoint in a minimal api in .Net 8.0 following the Domain, Application, Infrastructure, WebApi architecture, using MediatR to handle request.

Suppose I want to edit one Entity
I have a Get repository method that returns Task<Option<Entity>> :

public async Task<Option<Entity>> Get(int id) 
{
            return await DbContext.Entities.
                .SingleOrDefaultAsync(e => e.Id== id);
}

And Update:

public async Task Update(Entity entity)
        {
            DbContext.Entities.Update(entity);
            await DbContext.SaveChangesAsync();
        }

Then I have a handler for the edit request that initially i wanted to implement it like this:

	public async Task<Option<Entity>> Handle(EditCommand request, CancellationToken cancellationToken)
	{
	  var entity = await _entityRepo.Get(request.Id); // _entityRepo as dependency injection 

	  entity.Do(async e =>
	     {
		e.UpdateThings(request.ThingToUpdate);
                await _entityRepo.Update(e)  
               });

	  return entity;
	}

Finally I have the endpoint :

	app.MapPost("/{entity_id}", async (long entity_id, EditDto editDto, IMediator mediator) =>
	{
	  var command = new EditCommand(entity_id, editDto);
	  var entity = await mediator.Send(command);
	  return entity.Match(
			  Some: e => Results.Ok(e),
			  None: () => Results.NotFound()
			  );
	})

This code returns an exception Unhandled exception. System.ObjectDisposedException: Cannot access a disposed context instance. Object name: 'ApplicationDbContext'.

I got it to work changing the handler like this:

	public async Task<Option<Task<Entity>>> Handle(EditCommand request, CancellationToken cancellationToken)
	{
	  var entity = await _entityRepo.Get(request.Id); // _entityRepo as dependency injection 

	  return entity.Map<Task<Entity>>(async e =>
	     {
		e.UpdateThings(request.ThingToUpdate);
                await _entityRepo.Update(e) 
                return e
               });
	}

Then the endpoint like this:

	app.MapPost("/{entity_id}", async (long entity_id, EditDto editDto, IMediator mediator) =>
	{
	  var command = new EditCommand(entity_id, editDto);
	  var entity = await mediator.Send(command);
	 return await entity.MatchAsync(
	    Some: async e=> Results.Ok( await e),
	    None: () => Results.NotFound()
         );

	})

That is a lot of awaits... Surely I am misusing this features... Please can someone clarify me what's the best approach in this kind of situations? Thanks. I have read the docs and seen the ContoseApp sample but that did not help much...

[louthy]

Not sure what you're asking here? You're using 5 non-language-ext libraries and just one type from language-ext (Option), which doesn't seem related to your question and you want help on the non-language-ext bits? You've chosen to go the OO route, which is fine, but there is no magic solution to make you use less awaits (if you insist on taking the OO route).

If you want to get more into an FP style then check out the wiki. Starting with the Thinking Functionally tutorials. Once you understand the basics then it's worth looking at the How to deal with side effects section as it covers wrapping up your IO (talking to databases, etc.) in a runtime which can then be composed with zero awaits (the EffectsExamples sample app show this done for real.

[Gu4ty]

Yes, I need to learn more about the FP world. Thank you for the timely response. I will check out the resources.