Src Pro

22. Error Handling

4 min read

Error Handling in ASP.NET Core MVC

Error handling is a crucial aspect of building robust and user-friendly web applications. In ASP.NET Core MVC, it involves gracefully handling exceptions, providing informative feedback to users, and ensuring the application continues to function smoothly even when unexpected errors occur.

Exception Handling Middleware

Exception handling middleware is a type of custom middleware in ASP.NET Core that catches exceptions thrown during the request processing pipeline. This middleware allows you to:

  • Centralize Error Handling: Implement a single point where you can catch and handle exceptions.
  • Custom Error Responses: Generate appropriate error responses (HTML pages, JSON messages).
  • Logging: Log exceptions and their details for troubleshooting and analysis.

Custom Exceptions

In some scenarios, you might want to define your own custom exceptions to represent specific error conditions in your application.

public class CustomNotFoundException : Exception
{
    public CustomNotFoundException(string message) : base(message) { }
}

UseExceptionHandler Middleware

The UseExceptionHandler middleware is a built-in middleware component in ASP.NET Core that handles unhandled exceptions in your application.

  • Custom Error Pages: Configure it to redirect to a specific error page or endpoint (e.g., /Error).
  • Development vs. Production: In development, use UseDeveloperExceptionPage; in production, use UseExceptionHandler.

Code Example

// ExceptionHandlingMiddleware.cs
 
public class ExceptionHandlingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<ExceptionHandlingMiddleware> _logger;
    private readonly IDiagnosticContext _diagnosticContext; // For enriching Serilog logs
 
    public ExceptionHandlingMiddleware(RequestDelegate next, ILogger<ExceptionHandlingMiddleware> logger, IDiagnosticContext diagnosticContext)
    {
        _next = next;
        _logger = logger;
        _diagnosticContext = diagnosticContext;
    }
 
    public async Task Invoke(HttpContext httpContext)
    {
        try
        {
            await _next(httpContext); // Invoke the next middleware
        }
        catch (Exception ex)
        {
            // Log the inner exception if present, otherwise log the original exception
            if (ex.InnerException != null)
            {
                _logger.LogError("{ExceptionType} {ExceptionMessage}", ex.InnerException.GetType().ToString(), ex.InnerException.Message);
            }
            else
            {
                _logger.LogError("{ExceptionType} {ExceptionMessage}", ex.GetType().ToString(), ex.Message);
            }
 
            throw; // Re-throw the exception for further handling
        }
    }
}
 
// Extension method for easy registration
public static class ExceptionHandlingMiddlewareExtensions
{
    public static IApplicationBuilder UseExceptionHandlingMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<ExceptionHandlingMiddleware>();
    }
}

Program.cs

var app = builder.Build();
 
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage(); // Detailed error page in development
}
else
{
    app.UseExceptionHandler("/Error"); // Redirect to a custom error page in other environments
    app.UseExceptionHandlingMiddleware(); // Use the custom exception handling middleware
}
 
// ... (other middleware and routing) ...
  • UseDeveloperExceptionPage(): Enabled only in Development environment.
  • UseExceptionHandler("/Error"): Redirects to the /Error endpoint in non-development environments.
  • UseExceptionHandlingMiddleware(): Registers your custom exception handling middleware.

Notes

  • Centralized Error Handling: Use exception handling middleware or UseExceptionHandler.
  • Environment-Specific Behavior: Provide detailed error info in development, generic pages in production.
  • Custom Exceptions: Create custom exceptions for specific error conditions.
  • Logging: Always log exceptions for troubleshooting.
  • User-Friendly Error Messages: Provide clear and informative messages.
  • Testing: Write unit tests for your exception handling middleware.

Key Points to Remember

Goals

  • Graceful Recovery: Handle exceptions smoothly, preventing application crashes.
  • User Experience: Provide informative and helpful error messages.
  • Security: Avoid exposing sensitive information in error responses.
  • Maintainability: Centralize error handling logic.

Key Techniques

  • Exception Handling Middleware: Custom middleware that catches exceptions during the request pipeline.
  • UseExceptionHandler Middleware: Built-in middleware for handling unhandled exceptions, redirects to a specific error page.
  • UseDeveloperExceptionPage Middleware: Detailed error page with stack trace, only for development.
  • Custom Exceptions: Create your own exception classes for specific error conditions.

Best Practices

  • Centralized Handling: Use middleware to manage exceptions in one place.
  • Environment-Specific Errors:
    • Development: Use UseDeveloperExceptionPage.
    • Production: Use UseExceptionHandler for generic error pages.
  • Custom Exceptions: Create for specific error scenarios.
  • Logging: Always log exceptions with relevant details.
  • User-Friendly Messages: Provide clear and helpful error messages.
  • HTTP Status Codes: Use appropriate status codes (400, 404, 500, etc.).

Interview Tips

  • Explain the Flow: Articulate how exceptions are handled in ASP.NET Core MVC.
  • Custom Middleware: Discuss scenarios for creating custom exception handling middleware.
  • Custom Exceptions: Explain when and how to create custom exception classes.
  • Security: Emphasize protecting sensitive information in error responses.
  • User Experience: Highlight the need for user-friendly error messages.

Graph View