Asp.Net Mvc Global Error Handling Complete Guide

ASP.NET MVC Global Error Handling

Key Concepts

1. Exception Filters: ASP.NET MVC provides exception filters like custom attributes that can intercept and handle exceptions when they occur in a controller action. The most commonly used one is HandleErrorAttribute.

2. Application Level Error Handling: This involves setting up error handlers within the Global.asax file, which is the entry point for handling HTTP requests in MVC applications.

3. Logging: Integrating logging mechanisms with your error handling setup is essential to track exceptions over time and analyze them for debugging purposes.

4. Custom Error Pages: Displaying user-friendly custom error pages instead of generic server errors enhances the usability and professionalism of your application.

5. Elmah (Error Logging Modules and Handlers): An open-source library that integrates seamlessly into MVC applications for comprehensive error logging and notification.

6. HTTP Error Codes: Properly setting HTTP error codes (e.g., 400 Bad Request, 404 Not Found, 500 Internal Server Error) ensures accurate communication between the client and server.

7. Model State Validation: Ensuring model state is valid before processing actions prevents exceptions derived from invalid data entry, providing an additional layer of error prevention.

8. Try-Catch Blocks: Localizing try-catch blocks within controller actions for specific exceptions can complement global error handling by targeting exceptional scenarios precisely.

9. Dependency Injection: Utilizing dependency injection for error handling can make your code more maintainable and testable.

10. Unit Testing: Writing unit tests for error handling ensures that your error management logic is reliable during the development phase.

11. Integration with External Services: Logging errors to external services or notifying developers via email/SMS can improve the response time to critical issues.

Implementation Details

Using HandleErrorAttribute The HandleErrorAttribute is an exception filter attribute that can be applied globally or on individual controllers/actions.

[HandleError]
public class HomeController : Controller
{
    public ActionResult Index()
    {
        throw new Exception("An example exception");
    }
}

// Global usage in FilterConfig.cs
public class FilterConfig
{
    public static void RegisterGlobalFilters(GlobalFilterCollection filters)
    {
        filters.Add(new HandleErrorAttribute());
    }
}

• This attribute handles exceptions by redirecting users to a predefined error view (Error.cshtml) based on settings.
• Configure the attribute in web.config and FilterConfig.cs to specify which types of exceptions it should handle.

Overriding OnException Method Alternatively, you can override the OnException method in your base controller to provide custom exception handling behavior.

public class BaseController : Controller
{
    protected override void OnException(ExceptionContext filterContext)
    {
        if (!filterContext.ExceptionHandled) // Check to see if already handled.
        {
            // Log the exception here using your logging mechanism.
            
            // Redirect to a custom error view or page.
            filterContext.Result = View("CustomErrorView");
            filterContext.ExceptionHandled = true;
        }
        base.OnException(filterContext);
    }
}

public class HomeController : BaseController
{
    public ActionResult Index()
    {
        throw new Exception("An example exception");
    }
}

• This approach offers more flexibility and control over how exceptions are managed compared to using attributes alone.

Using Application_Error in Global.asax For global exception handling outside of specific controllers, you can use the Application_Error method in Global.asax.

void Application_Error(object sender, EventArgs e)
{
    // Get the exception object.
    Exception exception = Server.GetLastError();
    
    switch (exception)
    {
        case HttpException httpException:
            // Log the exception.
            break;
        default:
            // Log the exception.
            break;
    }

    // Respond to the error.
    Server.ClearError(); // Clear the default error.
    Response.Redirect("~/ErrorPage"); // Redirect to a custom error page.
}

• This method is triggered for unhandled exceptions anywhere in the MVC pipeline.
• Remember to clear the error after handling it to prevent the default error handlers from interfering.

Logging Exceptions Integrating logging into your error handling process is crucial for maintaining and debugging your application. There are several libraries available for logging, including Elmah, NLog, and Log4Net.

Elmah Example:

// Install Elmah using NuGet packages manager
ELMAH.ErrorSignal.FromCurrentContext().Raise(exception);

NLog Example:

using NLog;

var logger = LogManager.GetCurrentClassLogger();
logger.Error(exception);

Creating Custom Error Views Custom error views can be designed to provide a user-friendly interface when an error occurs.

• Use Web.config to specify custom error pages for different HTTP status codes.

<configuration>
    <system.web.webPages.razor>
        <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=5.2.7.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
        <pages pageBaseType="System.Web.Mvc.WebViewPage">
        </pages>
    </system.web.webPages.razor>
    <system.web>
        <customErrors mode="On" defaultRedirect="~/Error">
            <error statusCode="404" redirect="~/NotFound" />
            <error statusCode="500" redirect="~/ServerError" />
        </customErrors>
    </system.web>
</configuration>

• Design views (Error.cshtml, NotFound.cshtml, ServerError.cshtml) to display appropriate messages and information.

Model State Validation Validate models and data entries to prevent invalid data from causing errors.

public ActionResult Create(MyModel model)
{
    if (!ModelState.IsValid)
    {
        // Return the same view passing model.
        return View(model);
    }

    try
    {
        // Perform your create operation here.
    }
    catch (Exception ex)
    {
        ModelState.AddModelError("",ex.Message); 
        return View(model);
    }

    return RedirectToAction("Index");
}

• Display validation summary or error messages to guide users in correcting their input.

Handling Specific Exceptions Localize try-catch blocks for specific exceptions within controller actions to offer fine-grained control.

public ActionResult Update(int id, MyModel model)
{
    try
    {
        // Perform update operation
    }
    catch (NullReferenceException nre)
    {
        // Handle specifically
        return new HttpStatusCodeResult(HttpStatusCode.BadRequest, nre.Message);
    }
    catch (Exception ex)
    {
        // General exception handling
        return View("Error", ex.Message);
    }
    
    return RedirectToAction("Index");
}

• Avoid catching all exceptions in a single try-catch block as this can obscure specific exceptional cases.

Testing Error Handling Ensure thorough testing of your error handling strategy by simulating potential exceptions and verifying that your application responds appropriately.

• Write unit tests for controller actions that have specific exception handling.
• Use integration tests to verify global error handling configurations.

Conclusion Global error handling in ASP.NET MVC should be a combination of attributes, controllers, and configuration, along with proper logging mechanisms. It ensures that your application remains resilient to unexpected issues, logs meaningful data for debugging, and presents user-friendly custom error views, significantly contributing to the quality and reliability of your web application. By following these best practices and integrating Elmah or similar logging tools, you can establish a robust error handling framework for your MVC application.

Important Info Summary

• HandleErrorAttribute: Applied on controllers/actions, redirects to a custom error view.
• Global.asax's Application_Error: Handles all uncaught exceptions in the application.
• Elmah: An open-source library for detailed error logging and alerts.
• Logging: Essential for debugging and tracking issues, supports various logging levels.
• Custom Error Views: Provides user-friendly experiences during failures.
• Model State Validation: Prevents exceptions by validating input data before processing.
• Specific Exception Handling: Use try-catch blocks within actions for granular error management.
• Testing: Crucial to verify that the error handling works as expected under real conditions.