6. ASP.NET Core — every way to handle exceptions

if (app.Environment.IsDevelopment()) app.UseDeveloperExceptionPage();   // on by default in Development with WebApplication

builder.Services.AddProblemDetails(o =>
    o.CustomizeProblemDetails = ctx => ctx.ProblemDetails.Extensions["traceId"] = Activity.Current?.Id ?? ctx.HttpContext.TraceIdentifier);
builder.Services.AddExceptionHandler<AppExceptionHandler>();   // can register several; they run in order until one returns true

var app = builder.Build();
app.UseExceptionHandler();        // MVC apps: app.UseExceptionHandler("/Home/Error") for an HTML page
app.UseStatusCodePages();         // ProblemDetails/HTML bodies for empty 4xx/5xx responses (e.g. 404)

public sealed class AppExceptionHandler(ILogger<AppExceptionHandler> logger, IProblemDetailsService problems) : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext http, Exception ex, CancellationToken ct)
    {
        var (status, title) = ex switch
        {
            NotFoundException => (StatusCodes.Status404NotFound, "Resource not found"),
            BusinessRuleException => (StatusCodes.Status422UnprocessableEntity, "Business rule violated"),
            ConflictException or DbUpdateConcurrencyException => (StatusCodes.Status409Conflict, "Conflict"),
            ValidationException => (StatusCodes.Status400BadRequest, "Validation failed"),
            OperationCanceledException => (499, "Client closed request"),
            _ => (StatusCodes.Status500InternalServerError, "An unexpected error occurred")
        };
        if (status >= 500) logger.LogError(ex, "Unhandled exception for {Method} {Path}", http.Request.Method, http.Request.Path);
        else logger.LogWarning("Handled {Exception}: {Message}", ex.GetType().Name, ex.Message);

        http.Response.StatusCode = status;
        return await problems.TryWriteAsync(new ProblemDetailsContext
        {
            HttpContext = http,
            Exception = ex,
            ProblemDetails = new ProblemDetails
            {
                Status = status,
                Title = title,
                Detail = status < 500 ? ex.Message : null,      // never leak internals for 500s
                Extensions = { ["errorCode"] = (ex as AppException)?.ErrorCode }
            }
        });
    }
}

public sealed class ErrorHandlingMiddleware(RequestDelegate next, ILogger<ErrorHandlingMiddleware> logger)
{
    public async Task InvokeAsync(HttpContext context)
    {
        try { await next(context); }
        catch (Exception ex)
        {
            logger.LogError(ex, "Unhandled exception");
            if (context.Response.HasStarted) throw;                   // can't change a response already being sent
            context.Response.StatusCode = 500;
            await context.Response.WriteAsJsonAsync(new { title = "Unexpected error", traceId = context.TraceIdentifier });
        }
    }
}
app.UseMiddleware<ErrorHandlingMiddleware>();                          // register FIRST so it wraps everything

public sealed class DomainExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext ctx)
    {
        if (ctx.Exception is BusinessRuleException br)
        {
            ctx.Result = new UnprocessableEntityObjectResult(new ProblemDetails { Title = br.Message, Status = 422 });
            ctx.ExceptionHandled = true;
        }
    }
}
builder.Services.AddControllers(o => o.Filters.Add<DomainExceptionFilter>());