How to Implement Circuit breaker design pattern in .net core

Hello S A,

You install the Polly Package and implement the circuit breaker pattern.

You can refer to the below links.

https://codingcanvas.com/implementing-retry-and-circuit-breaker-pattern-using-polly/

https://www.twilio.com/blog/using-polly-circuit-breakers-resilient-net-web-service-consumers

public class UserService
{
    public void CreateUser(string username)
    {
        // Simulate external service call to create user
        throw new Exception("Failed to create user");
    }

    public string GetUser(int userId)
    {
        // Simulate external service call to get user
        throw new Exception("Failed to get user");
    }

    public void UpdateUser(int userId, string newUsername)
    {
        // Simulate external service call to update user
        throw new Exception("Failed to update user");
    }

    public void DeleteUser(int userId)
    {
        // Simulate external service call to delete user
        throw new Exception("Failed to delete user");
    }
}

public class CircuitBreaker
{
    // ... (previous circuit breaker implementation)

    public T ExecuteFunction(Func function)
    {
        if (_currentState == CircuitState.Open)
        {
            throw new CircuitOpenException("Circuit is open");
        }

        try
        {
            T result = function();
            _failureCount = 0;
            return result;
        }
        catch (Exception ex)
        {
            _failureCount++;
            if (_failureCount >= _failureThreshold)
            {
                OpenCircuit();
            }
            throw;
        }
    }
}

public class UserServiceWithCircuitBreaker
{
    private UserService _userService;
    private CircuitBreaker _circuitBreaker;

    public UserServiceWithCircuitBreaker(UserService userService, CircuitBreaker circuitBreaker)
    {
        _userService = userService;
        _circuitBreaker = circuitBreaker;
    }

    public void CreateUser(string username)
    {
        _circuitBreaker.ExecuteFunction(() => _userService.CreateUser(username));
    }

    public string GetUser(int userId)
    {
        return _circuitBreaker.ExecuteFunction(() => _userService.GetUser(userId));
    }

    public void UpdateUser(int userId, string newUsername)
    {
        _circuitBreaker.ExecuteFunction(() => _userService.UpdateUser(userId, newUsername));
    }

    public void DeleteUser(int userId)
    {
        _circuitBreaker.ExecuteFunction(() => _userService.DeleteUser(userId));
    }
}

// Startup.cs

public void ConfigureServices(IServiceCollection services)

{

    // ...

    services.AddScoped();

    services.AddSingleton();

    services.AddScoped();

    // ...

}

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class UserController : ControllerBase
{
    private readonly UserServiceWithCircuitBreaker _userService;

    public UserController(UserServiceWithCircuitBreaker userService)
    {
        _userService = userService;
    }

    [HttpPost]
    public IActionResult CreateUser([FromBody] CreateUserRequest request)
    {
        try
        {
            _userService.CreateUser(request.Username);
            return Ok("User created successfully");
        }
        catch (CircuitOpenException)
        {
            return StatusCode(503, "Service unavailable");
        }
        catch (Exception)
        {
            return StatusCode(500, "An error occurred");
        }
    }

    [HttpGet("{userId}")]
    public IActionResult GetUser(int userId)
    {
        try
        {
            var user = _userService.GetUser(userId);
            return Ok(user);
        }
        catch (CircuitOpenException)
        {
            return StatusCode(503, "Service unavailable");
        }
        catch (Exception)
        {
            return StatusCode(500, "An error occurred");
        }
    }

    // Other CRUD methods similarly
}

In your application's startup or configuration, set up a Circuit Breaker policy using Polly. You can do this by creating a custom policy with specified failure thresholds and time durations.

Example:

using Polly;
using Polly.CircuitBreaker;

// Create a custom Circuit Breaker policy
var circuitBreakerPolicy = Policy.Handle()
    .CircuitBreakerAsync(3, TimeSpan.FromSeconds(30),
        (ex, duration) =>
        {
            // Handle the circuit being broken
            Console.WriteLine("Circuit breaker opened due to too many exceptions.");
        },
        () =>
        {
            // Handle the circuit being reset
            Console.WriteLine("Circuit breaker reset.");
        });

// Register the policy with your dependency injection container
services.AddSingleton(circuitBreakerPolicy);