Using MediatR in Web API - How do you handle different status codes - asp.net-core-webapi

Question

I am using (and learning how to use) MediatR and am trying to use it in my Web API. My question is, assuming that the goal of the 'controller' is to look like the following where you simply send off the message:
[ApiController]
public class List : ControllerBase
{
private readonly IMediator mediator;
public List( IMediator mediator )
{
this.mediator = mediator;
}
[HttpGet( "/calc-engines" )]
public async Task<ActionResult<CalcEngine[]>> HandleAsync(
[FromQuery] Query query,
CancellationToken cancellationToken = default ) => await mediator.Send( query, cancellationToken );
What is the best practice to handle different status codes based on item not found, forbidden, etc.?
Do you have your handler return a complex type with a Payload (the requested item) along with an HttpStatus and then examine the result in the action and return appropriately? Throw exceptions and catch in the action (or a filter) and set status based on exception type?
Update: This is the best I could come up with, but wondering if there is something better.
public class ApiResult<T>
{
private ApiResult( HttpStatusCode failureStatus ) => FailureStatus = failureStatus;
private ApiResult( T payload ) => Payload = payload;
public T Payload { get; }
public HttpStatusCode? FailureStatus { get; }
public bool IsSuccess => FailureStatus == null;
public static ApiResult<T> Fail( HttpStatusCode failureStatus ) => new ApiResult<T>( failureStatus );
public static ApiResult<T> Success( T paylooad ) => new ApiResult<T>( paylooad );
public static implicit operator bool( ApiResult<T> result ) => result.IsSuccess;
}
Then handler looks something like this:
public async Task<ApiResult<SomeType>> Handle( TRequest message, CancellationToken token )
{
if ( badValidation )
{
return ApiResult<SomeType>.Fail( HttpStatusCode.BadRequest );
}
// do work...
return ApiResult<SomeType>.Success( someResult );
}
And action looks something like this:
public async Task<ActionResult<ApiResult<SomeType>>> HandleAsync(
[FromQuery] Query query,
CancellationToken cancellationToken = default )
{
var result = await mediator.Send( query, cancellationToken );
if ( result ) return result;
return StatusCode( (int)result.FailureStatus );
}

Answer 1

In the team I take part, we detach the controller/presentation layer from the Mediatr logic (which will be in our application/business layer).
As you did, we return a specified object result from the Mediatr commands/queries, stating success/unsuccess, holding the result payload or errors. However, we do not return HTTP status codes, since that is responsability of the controller - the controller handles the HTTP requests and responses, so only the controller needs to know the meaning of Ok, Bad Request, etc. In this way, we decouple the presentation and the application layers (we employ a clean architecture scheme).
Thus, to map Meditr results in APIs, we often use two different strategies:
Middlewares to model responses. Example: if an input validation exception is thrown, a middleware catches it and retrieves a Bad Request;
Methods in the controllers to interpret responses. Examples: if a Get endpoint calls a query and the result payload is null, that is mapped to a Not Found; if a failed result is returned by the Mediatr, a 500 is returned.
Pipeline behaviours (reference) may also be useful to you. They are classes that can be registered in the pipelines of commands/queries, executing in the specified order as middlewares. They are very useful, for example, to validate input conditions, handle exceptions, model responses, get metrics, etc. In your example, the following validation
if ( badValidation )
{
return ApiResult<SomeType>.Fail( HttpStatusCode.BadRequest );
}
could go to a validation behaviour, for example, instead of staying inside the Handle. Here is a good tutorial.

Answer 2

public class ErrorHandler:Exception
{
public HttpStatusCode Codigo { get; set; }
public object Error { get; set; }
public ErrorHandler(HttpStatusCode Code, object Err)
{
this.Codigo = Code;
this.Error = Err;
}
}
i work with mediatr and i handle exceptions with this code. usage example bellow
var Comment = await contexto.TComentario.FindAsync(request.CommentId);
if (Comment == null)
throw new ManejadorErr.ErrorHandler(System.Net.HttpStatusCode.NotFound, new { Message = "comment no could be found" });