Repository results and status codes in ASP.NET Core API Controller methods

Question

I have an ASP.NET Core API app and I'm using IActionResult for a return type. For an example, I'll use the following snippet from Microsoft's documentation:

[HttpGet("{id}")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public IActionResult GetById(int id)
{
    if (!_repository.TryGetProduct(id, out var product))
    {
        return NotFound();
    }

    return Ok(product);
}

My controllers are similar, where routes are using the IActionResult and using functions such as NotFound(), BadRequest(), or Ok() and following the repository pattern for obtaining data from a database. In Microsoft's trivial example, they're simply evaluating if the result is null, and if it is they'll return NotFound().

In the repository logic, there could be any number of issues that occurred. For example:

• DB query success, but product wasn't found (404 not found)
• DB query failure, connection string was invalid (500 server error)
• Product ID didn't pass some validation test (400 bad request)

In all of the above cases, you could maybe justify returning null from the TryGetProduct() function, since it wasn't able to retrieve a product in any of those cases. But returning null as a general return result from a repository function doesn't seem helpful and could mean any number of issues occurred. What's the best way I can return data from a repository to allow the controller to then determine the appropriate status code to return and what are the best practices for this?

Answer 1

I would like to show my way.

You can try to configure Exception Handler.

Create new class ExceptionMiddlewareExtension like :

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Http;
using System;
using System.Net;

namespace Project.Middleware
{
public static class ExceptionMiddlewareExtension
  {
    public static void ConfigureExceptionHandler(this IApplicationBuilder app)
    {
        app.UseExceptionHandler(appError =>
        {
            appError.Run(async context =>
            {
                context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;
                context.Response.ContentType = "application/json";

                var contextFeature = context.Features.Get<IExceptionHandlerFeature>();
                if (contextFeature != null)
                {
                    ResponseModel<string> responseModel = new ResponseModel<string>();
                    if(contextFeature.Error is Exception)
                    {
                        responseModel.Errors.Add(new ErrorModel()
                        {
                            ErrorCode = context.Response.StatusCode.ToString(),
                            Message = contextFeature.Error.Message
                        });
                    }
                    responseModel.Result = false;
                    await context.Response.WriteAsync(responseModel.ToString());
                }
            });
        });
    }
  }
}

Create Response Model:

using System.Collections.Generic;
using Newtonsoft.Json;

namespace Project.Domain
{
public class ResponseModel<T>
  {
    public ResponseModel()
    {
        Errors = new List<ErrorModel>();
    }

    public ResponseModel(T data)
    {
        Data = data;
        Result = true;
    }

    public ResponseModel(List<ErrorModel> errors)
    {
        Errors = errors;
    }

    public bool Result { get; set; }
    public T Data { get; set; }
    public List<ErrorModel> Errors { get; set; }
    

    public override string ToString()
    {
        return JsonConvert.SerializeObject(this);
    }
  }
}

Create Error Model:

using Newtonsoft.Json;
namespace Projec.Domain
{
    public class ErrorModel
    {
        public string Message { get; set; }

        public string ErrorCode { get; set; }
        
        public string Code { get; set; }
        
        public override string ToString()
        {
            return JsonConvert.SerializeObject(this);
        }
    }
}

And then in your Startup.cs add below line to Configure():

app.ConfigureExceptionHAndler();

On the other hand to check your request params is valid you can try ActionFilterAttribute like :

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;

namespace Project.Middleware
{
    public class ModelStateValidationAttribute : ActionFilterAttribute
    {
        public override void OnActionExecuting(ActionExecutingContext context)
        {
            if (!context.ModelState.IsValid)
            {
                context.Result = new UnprocessableEntityObjectResult(context.ModelState);
            }
        }
    }
}

Briefly, i use this way and clearly enough. Your all request will go through filter and middleware. Just use Try-Catch in your managers(or check your object is null) and if something go wrong then throw new Exception(msg).

Also you can write your custome exception model and throw. Then add your model to middleWare to check contextFeature.Error is CustomException

I hope it will be helpful.