Understanding the IExceptionHandler in .NET 8 for Global Exception Handling

[hptruc]

Hello everyone,

I've been using a custom middleware approach for handling global exceptions in my .NET applications, which involves creating a new middleware and injecting it into the middleware pipeline using the UseMiddleware method as shown below:

// ExceptionHandlingMiddleware.cs
public class ExceptionHandlingMiddleware(RequestDelegate next)
{
    public async Task Invoke(HttpContext context)
    {
        try
        {
            await next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }

    private static Task HandleExceptionAsync(HttpContext context, Exception exception)
    {   
        // Process exception here...
    }
}

// Program.cs
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.UseMiddleware<ExceptionHandlingMiddleware>();

However, I noticed that .NET 8 introduces a new feature for handling global exceptions, IExceptionHandler. This interface seems to offer a structured way to handle exceptions globally, but I'm not entirely clear on the advantages or the key differences it brings compared to the traditional middleware approach. The basic usage of IExceptionHandler is as follows:

public class GlobalExceptionHandler : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext httpContext, Exception exception, CancellationToken cancellationToken)
    {
        // Process exception here...
    }
}

// Program.cs
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddExceptionHandler<GlobalExceptionHandler>();
var app = builder.Build();
app.UseExceptionHandler(option => {});

Could someone explain the key benefits or differences of using IExceptionHandler over the traditional middleware approach for global exception handling? Specifically, I'm interested in understanding any improvements in performance, ease of use, flexibility, or any other aspects that IExceptionHandler might offer.

Thank you in advance for your insights!

[kimbell]

I've been where you are; we created custom middleware and a bunch of extensibility options. We are now in the process of throwing that out and replacing it with the standard middleware and IExceptionHandler.

There are multiple reasons for why we are doing this.

• Less code we need to maintain
• Can rely on standard MS documentation
• Middleware adds metrics
  

  aspnetcore/src/Middleware/Diagnostics/src/ExceptionHandler/ExceptionHandlerMiddlewareImpl.cs

  Line 126 in 9465655

  _metrics.RequestException(exceptionName, ExceptionResult.Aborted, handler: null);

• Middleware has handling of OperationCanceledException and IOException
  

  aspnetcore/src/Middleware/Diagnostics/src/ExceptionHandler/ExceptionHandlerMiddlewareImpl.cs

  Line 117 in 9465655

  if ((edi.SourceException is OperationCanceledException || edi.SourceException is IOException) && context.RequestAborted.IsCancellationRequested)

• If your exception handler returns 404 for an exception, you have to manually enable this possibility.
  

  aspnetcore/src/Middleware/Diagnostics/src/ExceptionHandler/ExceptionHandlerOptions.cs

  Line 40 in 9465655

  public bool AllowStatusCode404Response { get; set; }

When MS makes improvements, we get it for free.