.NET Core - Error Handling

Error handling in ASP.NET Core Web API involves handling and responding to exceptions that occur during the processing of HTTP requests. Exception handling is one of the most important features of any application. Fortunately, ASP.NET Core includes a middleware that makes exception handling easy. Here's an overview of the common approaches for error handling in ASP.NET Core Web API.

There are three common approaches for error handling in ASP.NET Core Web API.

1. Global Error Handling
2. Custom Exception Middleware
3. Action-level Exception Handling

1. Global Error Handling

Global exception handling is a mechanism that allows you to catch and handle any exceptions that occur within your application. It enables you to handle errors in a consistent manner and provides a way to log the error messages, notify the user, and gracefully terminate the application if necessary. You can configure global error handling by using the UseExceptionHandler middleware in the Configure method of your Startup.cs file. This middleware catches unhandled exceptions and returns an appropriate error response.

Example

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
     //Other middleware configurations.
     app.UseExceptionHandler("/error");
    //Other middleware configurations.
}

In the above example, the UseExceptionHandler middleware is configured to redirect to the /error endpoint when an exception occurs.

2. Custom Exception Middleware

You can create custom middleware to handle exceptions and return specific error responses. This approach allows you to have more control over the error handling process. Here is an example of a custom exception middleware.

public class ExceptionMiddleware
{
    private readonly RequestDelegate _next;

    public ExceptionMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            // Handle the exception and return an appropriate error response
            await HandleExceptionAsync(context, ex);
        }
    }

    private static async Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
        // Create an error response based on the exception
        var response = new { error = exception.Message };

        // Set the response status code and content type
        context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
        context.Response.ContentType = "application/json";

        // Serialize the response as JSON and write it to the response body
        await context.Response.WriteAsync(JsonConvert.SerializeObject(response));
    }
}

Register the custom middleware in the Configure method of your Startup.cs file.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    //Other middleware configurations...
    app.UseMiddleware<ExceptionMiddleware>();
   //Other middleware configurations
}

This middleware will catch exceptions and return an appropriate error response.

3. Action-level Exception Handling

You can handle exceptions at the action level by using try-catch blocks within your controller actions. This allows you to handle specific exceptions differently and return customized error responses.

Example

[HttpGet("{id}")]
public IActionResult Get(int id)
{
    try
    {
        // Perform some operation that may throw an exception
        var result = _service.GetData(id);
        return Ok(result);
    }
    catch (NotFoundException ex)
    {
        // Handle specific exception types and return a corresponding error response
        return NotFound(ex.Message);
    }
    catch (Exception ex)
    {
        // Handle other exceptions and return a generic error response
        return StatusCode(500, "An error occurred.");
    }
}

In the above example, the Get action catches a NotFoundException and returns a 404 Not Found response with the exception message. Other exceptions are caught in the generic Exception catch block and return a 500 Internal Server Error response.

These are some of the common approaches to handle errors in ASP.NET Core Web API. You can choose the approach that best suits your requirements and the level of control you need over the error handling process.