The Circuit Breaker Design Pattern

In software engineering, it is important to write code that is robust and resilient to unexpected errors. One way to achieve this is by using design patterns, which are reusable solutions to common problems that developers face. One such pattern is the Circuit Breaker design pattern, which is used to improve the resilience of a system by detecting and handling errors in a graceful manner. In this article, we will explore the Circuit Breaker design pattern in C# with examples.

What is the Circuit Breaker design pattern?

The Circuit Breaker design pattern is used to prevent cascading failures in a system by detecting and handling errors in a controlled manner. It is similar to the circuit breaker in electrical systems, which is used to protect the system from overloading. In a software system, the Circuit Breaker design pattern is used to detect when a service or component is not responding or behaving incorrectly, and then "trip" the circuit breaker to prevent further calls to that service or component until it recovers.

The Circuit Breaker pattern has three states: closed, open, and half-open. When the circuit breaker is closed, requests are allowed to flow through to the service or component. If an error occurs, the circuit breaker opens, and requests are not allowed to flow through. After a specified time period, the circuit breaker transitions to the half-open state, during which a limited number of requests are allowed to flow through to the service or component. If the requests are successful, the circuit breaker transitions back to the closed state. If the requests fail, the circuit breaker reopens and remains in the open state for a longer period.

Example of Circuit Breaker Design Pattern in C

Let's say we have a C# application that makes HTTP requests to a third-party API. We can use the Circuit Breaker design pattern to handle errors that may occur when making requests to the API. The following code shows a simple implementation of the Circuit Breaker pattern in C#:

public class CircuitBreaker
{
    private readonly TimeSpan _timeout;
    private readonly int _failureThreshold;
    private int _failureCount;
    private DateTime _lastFailureTime;
    private CircuitState _state;

    public CircuitBreaker(TimeSpan timeout, int failureThreshold)
    {
        _timeout = timeout;
        _failureThreshold = failureThreshold;
        _state = CircuitState.Closed;
    }

    public async Task<T> ExecuteAsync<T>(Func<Task<T>> action)
    {
        switch (_state)
        {
            case CircuitState.Closed:
                try
                {
                    var result = await action();
                    _failureCount = 0;
                    return result;
                }
                catch (Exception ex)
                {
                    Trip(ex);
                    throw;
                }
            case CircuitState.Open:
                if (DateTime.UtcNow - _lastFailureTime > _timeout)
                {
                    _state = CircuitState.HalfOpen;
                }
                else
                {
                    throw new CircuitBreakerException("Circuit breaker is open");
                }
                break;
            case CircuitState.HalfOpen:
                try
                {
                    var result = await action();
                    _state = CircuitState.Closed;
                    _failureCount = 0;
                    return result;
                }
                catch (Exception ex)
                {
                    Trip(ex);
                    throw;
                }
            default:
                throw new ArgumentOutOfRangeException();
        }
        return default;
    }

    private void Trip(Exception ex)
    {
        _failureCount++;
        _lastFailureTime = DateTime.UtcNow;
        if (_failureCount >= _failureThreshold)
        {
            _state = CircuitState.Open;
        }
    }
}

public enum CircuitState
{
    Closed,
    Open,
    HalfOpen
}

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

In the code above, we have defined a CircuitBreaker class that takes two parameters in the constructor: timeout and failureThreshold. The timeout parameter is used to determine how long the circuit breaker stays open, and the failureThreshold parameter is the number of failures required to trip the circuit breaker.

The ExecuteAsync method is used to execute an asynchronous task that returns a result. It takes a function action as a parameter, which represents the task to be executed. When a request is made, the circuit breaker checks its current state and takes appropriate action based on the state. If the circuit breaker is closed, the action is executed, and the result is returned. If an exception is thrown, the circuit breaker trips and throws the exception.

If the circuit breaker is open, the action is not executed, and a CircuitBreakerException is thrown. If the circuit breaker is in the half-open state, a limited number of requests are allowed to flow through to the service or component. If the requests are successful, the circuit breaker transitions back to the closed state. If the requests fail, the circuit breaker reopens and remains in the open state for a longer period.

Conclusion

In this article, we have explored the Circuit Breaker design pattern in C#. We have seen how it can be used to prevent cascading failures in a system by detecting and handling errors in a controlled manner. We have also provided an example implementation of the pattern in C#. By using the Circuit Breaker design pattern, developers can improve the resilience of their applications and provide a better user experience for their users.