Custom Exception Implementation

Hey there, coding enthusiasts! Have you ever felt overwhelmed managing exceptions in your C# projects? Are those repetitive constructors and error codes scattered all over your codebase? Today, we're diving into a neat trick that can make your life a whole lot easier: using abstract classes, generics, and const strings for exception handling. Trust me, it’s a game-changer!

By the end of this guide, you'll have a solid understanding of how to streamline your exception handling, making your code cleaner, more efficient, and much easier to maintain. Imagine writing code that works flawlessly and is elegant and straightforward to read. Sounds pretty awesome, right? Let’s get into it!

TL;DR - version

Using abstract classes, generics, and const strings in your exception handling can improve the cleanliness, maintainability, and flexibility of your C# code. Custom exceptions offer improved specificity, readability, and error handling, making them a superior choice over the native Exception class for complex applications.

Abstract Classes: Provide a clear inheritance structure and centralize common logic to make code more manageable. However, this approach offers less flexibility for complex hierarchies and may lead to code duplication if different behaviours are needed.

Generics: Enhance flexibility and reusability by allowing type-safe code to be reused across different application parts. They do introduce complexity and require careful type management.

Const Strings for Error Codes: These centralized error code management methods improve readability and maintainability. They prevent hard coding and reduce the risk of typos, but they require managing an additional class for constants.

These patterns help create a robust and maintainable exception-handling system, making your code more efficient and easier to work with.

Why use Custom Exceptions?

Before we delve into the implementation details, let's discuss why you should consider using custom exceptions instead of the native Exception class. Custom exceptions offer several benefits:

• Specificity: Custom exceptions can represent specific error conditions, making it easier to understand and handle errors appropriately.
• Readability: They make your code more readable and maintainable by providing meaningful exception names.
• Error Handling: Custom exceptions can contain extra information, such as error codes and HTTP status codes, that are essential for error handling and debugging.

Alright, let's break it down. We will talk about three main concepts: abstract classes, generics, and const strings.

We'll see how these can help us handle exceptions more effectively.

Abstract Classes

Abstract classes provide a way to create a common base class with shared properties and methods, from which other classes can inherit, promoting consistency and reducing redundancy. Here’s an example:

C#

using System;
using System.Net;

public abstract class CustomExceptionBase : Exception
{
  public string CustomMessage { get; }
  public HttpStatusCode StatusCode { get; }
  public string ErrorCode { get; }

  protected CustomExceptionBase(string customMessage)
      : this(customMessage, string.Empty, HttpStatusCode.InternalServerError) { }

  protected CustomExceptionBase(string customMessage, string errorCode)
      : this(customMessage, errorCode, HttpStatusCode.InternalServerError) { }

  protected CustomExceptionBase(string customMessage, HttpStatusCode statusCode)
      : this(customMessage, string.Empty, statusCode) { }

  protected CustomExceptionBase(string customMessage, string errorCode, HttpStatusCode statusCode)
      : base(customMessage)
  {
      CustomMessage = customMessage;
      ErrorCode = errorCode;
      StatusCode = statusCode;
  }

  public override string ToString()
  {
      return $"Exception: {CustomMessage}, ErrorCode: {ErrorCode}, StatusCode: {StatusCode}";
  }
}

This approach centralizes common logic, making our code more manageable.

What if we need more flexibility? That's where generics come in.

Generics

Generics are super cool because they make it easy to create versatile and foolproof code. This means we can create exception classes that are more adaptable and can be reused in different situations.

Here's a similar example using generics:

C#

using System;
using System.Net;

public abstract class CustomExceptionBase<T> : Exception where T : CustomExceptionBase<T>
{
    public string CustomMessage { get; }
    public HttpStatusCode StatusCode { get; }
    public string ErrorCode { get; }

    protected CustomExceptionBase(string customMessage)
        : this(customMessage, string.Empty, HttpStatusCode.InternalServerError) { }

    protected CustomExceptionBase(string customMessage, string errorCode)
        : this(customMessage, errorCode, HttpStatusCode.InternalServerError) { }

    protected CustomExceptionBase(string customMessage, HttpStatusCode statusCode)
        : this(customMessage, string.Empty, statusCode) { }

    protected CustomExceptionBase(string customMessage, string errorCode, HttpStatusCode statusCode)
        : base(customMessage)
    {
        CustomMessage = customMessage;
        ErrorCode = errorCode;
        StatusCode = statusCode;
    }

    public override string ToString()
    {
        return $"Exception: {CustomMessage}, ErrorCode: {ErrorCode}, StatusCode: {StatusCode}";
    }
}

Generics add flexibility but can be a bit more complex to manage.

Let’s make our error codes more maintainable by using const strings

Const Strings for Error Codes

Using const strings for error codes ensures they are easy to manage and update. Here’s how you can define and use them:

C#

public static class ErrorCodes
{
    public const string NotFound = "NOT_FOUND";
    public const string Unauthorized = "UNAUTHORIZED";
    public const string BadRequest = "BAD_REQUEST";
}

Usage

And in our exception classes:

C#

public class NotFoundException : CustomExceptionBase<NotFoundException>
{
    public NotFoundException(string message)
        : base(message, ErrorCodes.NotFound, HttpStatusCode.NotFound) { }
}

public class UnauthorizedException : CustomExceptionBase<UnauthorizedException>
{
    public UnauthorizedException(string message)
        : base(message, ErrorCodes.Unauthorized, HttpStatusCode.Unauthorized) { }
}

public class BadRequestException : CustomExceptionBase<BadRequestException>
{
    public BadRequestException(string message)
        : base(message, ErrorCodes.BadRequest, HttpStatusCode.BadRequest) { }
}

Writing Unit Tests

Now, let's write unit tests to verify the behavior of our custom exceptions.

C#

Create a file named CustomExceptionTests.cs and add the following code.

using System;
using System.Net;
using Xunit;

public class CustomExceptionTests
{
    [Fact]
    public void NotFoundException_Should_Have_Correct_Properties()
    {
        // Arrange
        var message = "Resource not found";
        var exception = new NotFoundException(message);

        // Act & Assert
        Assert.Equal(message, exception.CustomMessage);
        Assert.Equal(ErrorCodes.NotFound, exception.ErrorCode);
        Assert.Equal(HttpStatusCode.NotFound, exception.StatusCode);
    }

    [Fact]
    public void UnauthorizedException_Should_Have_Correct_Properties()
    {
        // Arrange
        var message = "Unauthorized access";
        var exception = new UnauthorizedException(message);

        // Act & Assert
        Assert.Equal(message, exception.CustomMessage);
        Assert.Equal(ErrorCodes.Unauthorized, exception.ErrorCode);
        Assert.Equal(HttpStatusCode.Unauthorized, exception.StatusCode);
    }

    [Fact]
    public void BadRequestException_Should_Have_Correct_Properties()
    {
        // Arrange
        var message = "Bad request";
        var exception = new BadRequestException(message);

        // Act & Assert
        Assert.Equal(message, exception.CustomMessage);
        Assert.Equal(ErrorCodes.BadRequest, exception.ErrorCode);
        Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode);
    }

    [Fact]
    public void CustomExceptionBase_Should_Override_ToString()
    {
        // Arrange
        var message = "Test exception";
        var exception = new NotFoundException(message);
        var expectedString = $"Exception: {message}, ErrorCode: {ErrorCodes.NotFound}, StatusCode: {HttpStatusCode.NotFound}";

        // Act
        var result = exception.ToString();

        // Assert
        Assert.Equal(expectedString, result);
    }
}

Comparison and Benefits

Aspect	Pros	Cons
Abstract Classes	They provide simplicity, clear inheritance, and centralized logic.	There is less flexibility for complex hierarchies and a potential for code duplication.
Generics	Flexibility, reusability, type safety	More complex to manage, additional overhead in type management
Const Strings	Centralized management of error codes, improved readability and maintainability, avoids hard-coding	Requires managing an additional class for constants
Custom Exceptions	Specificity, readability, enhanced error handling	Slightly more setup required compared to using native exceptions

Benefits of Using Custom Exceptions

Specificity: Custom exceptions can represent specific error conditions, making it easier to understand and handle errors appropriately.

Readability: They improve your code's readability and maintainability by using meaningful exception name.

Error Handling: Custom exceptions can include additional information, such as error codes and HTTP status codes, which are essential for error handling and debugging.

Conclusion

So, there you have it! Combining abstract classes, generics, and const strings makes your exception handling in C# much more efficient and maintainable.

Try these patterns next time you're working on your C# projects.

Happy coding!

Every Bit of Support Helps!

If you have enjoyed this post, please consider buying me a coffee ☕ to help me keep writing!