Asp.Net Mvc Custom Error Pages Complete Guide

Top 10 Questions and Answers on ASP.NET MVC Custom Error Pages

Q1: How do I enable custom error pages in an ASP.NET MVC application?

A1: You can enable custom error pages by configuring the <customErrors> element in your Web.config file, setting the mode to “on” and specifying the path for your error page. Here's an example:

<system.web>
    <customErrors mode="On" defaultRedirect="~/Error/GeneralError">
        <error statusCode="404" redirect="~/Error/NotFound"/>
    </customErrors>
</system.web>

Q2: Can I use custom error pages with ASP.NET MVC 6 (Core)?

A2: In ASP.NET Core MVC, configuring custom error pages is different. You typically handle errors in the middleware pipeline using app.UseExceptionHandler. For example:

if (!env.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
}

You can also specify a custom status code response handler:

app.UseStatusCodePagesWithReExecute("/Home/Error", "?statusCode={0}");

Q3: What is the best way to handle 404 errors specifically in ASP.NET MVC?

A3: To handle 404 errors specifically, configure it as shown in Q1, or you can catch these in the controller using Action Filters. Here’s a filter example:

public class Handle404Attribute : ActionFilterAttribute
{
    public override void OnResultExecuted(ResultExecutedContext filterContext)
    {
        if(filterContext.Result is HttpNotFoundResult)
        {
            filterContext.HttpContext.Response.Redirect("~/Error/NotFound", true);
        }
    }
}

Alternatively, in ASP.NET Core, use the following approach:

public class HomeController : Controller
{
    [Route("{*url}", Order = int.MaxValue)]
    public IActionResult RouteNotFound()
    {
        return View("NotFound");
    }
}

Q4: Should I use global filters in ASP.NET MVC to catch and handle exceptions globally?

A4: Yes, utilizing global filters like HandleErrorAttribute allows you to catch unhandled exceptions and direct them to custom error pages. It’s defined in the Global.asax.cs file:

public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
    filters.Add(new HandleErrorAttribute());
}

Q5: How do I display a user-friendly message for a specific exception type?

A5: In ASP.NET Core, you can create a custom middleware to intercept specific types of exceptions and render a friendly view. Here’s a simple implementation:

public class ExceptionMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext httpContext)
    {
        try
        {
            await _next(httpContext);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(httpContext, ex);
        }
    }

    private static Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
        // Check exception type and redirect accordingly
        if(exception is InvalidOperationException)
        {
            context.Response.Redirect("/Error/InvalidOperation");
        }
        else
        {
            context.Response.Redirect("/Error/GeneralError");
        }
        return Task.CompletedTask;
    }
}

Q6: Why should I avoid using [HandleError] attributes directly over the actions in ASP.NET MVC?

A6: Overuse of [HandleError] attributes can lead to inconsistent error handling practices and make it harder to manage error logic across the application. It also won’t catch exceptions outside of controller actions or that occur in views.

Q7: Is it possible to show custom error messages during development without redirecting to an error page?

Q7: During development, keep the <customErrors> mode to “Off” to get detailed error messages, which are crucial for debugging. However, if redirection is still desired for testing purposes, you can create action methods that simulate errors and direct them to your error views.

Q8: How do I ensure that my custom error pages maintain the look and feel consistent with the rest of my application?

A8: Use partial views or layout views to ensure consistency across error pages. Inherit from a common base controller or use a custom error view model that contains navigation menus and other standard UI elements.

Q9: How can I log errors before displaying the custom error page?

A9: Log errors in the middleware or global exception filters before rendering the error page. For example, logging can be done using dependency injection in ASP.NET Core:

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;

    public LoggingMiddleware(RequestDelegate next, ILoggerFactory loggerFactory)
    {
        _next = next;
        _logger = loggerFactory.CreateLogger<LoggingMiddleware>();
    }

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch(Exception e)
        {
            _logger.LogError($"Something went wrong: {e}");

            var code = HttpContext.Features.Get<IExceptionHandlerPathFeature>()?.StatusCode;
            context.Response.Redirect(code == null? "/Home/Error" : $"/Home/Error/{code}");
        }
    }
}

Q10: How should I deal with AJAX requests that return error pages?

A10: Customize your HandleExceptionAsync method to detect AJAX requests and respond appropriately. For example, returning JSON data with error information:

private static Task HandleExceptionAsync(HttpContext context, Exception exception)
{
    context.Response.ContentType = "application/json";
    return exception switch
    {
        UnauthorizedAccessException => context.Response.WriteAsync(new ErrorDetailsModel(401, "Unauthorized").ToString()),
        KeyNotFoundException => context.Response.WriteAsync(new ErrorDetailsModel(404, "Not Found").ToString()),
        _ => context.Response.WriteAsync(new ErrorDetailsModel(500, $"Oops! Something went wrong. Details: {exception.Message}").ToString()),
    };
}

In older MVC, you might check the request header X-Requested-With to identify AJAX requests and send back JSON instead.