public abstract class CircuitBreakerState
{
    protected CircuitBreakerState(CircuitBreaker circuitBreaker)
    {
        this.circuitBreaker = circuitBreaker;
    }

/// <summary>
/// 调用受保护方法之前处理的操作
/// </summary>
public virtual void ProtectedCodeIsAboutToBeCalled() {
//如果是断开状态，直接返回
//然后坐等超时转换到半断开状态
if (circuitBreaker.IsOpen)
{
throw new OpenCircuitException();
}
}

/// <summary>
/// 受熔断器保护的方法调用成功之后的操作
/// </summary>
public virtual void ProtectedCodeHasBeenCalled()
{
circuitBreaker.IncreaseSuccessCount();
}

/// <summary>
///受熔断器保护的方法调用发生异常操作后的操作
/// </summary>
/// <param name="e"></param>
public virtual void ActUponException(Exception e)
{
//增加失败次数计数器，并且保存错误信息
circuitBreaker.IncreaseFailureCount(e);
//重置连续成功次数
circuitBreaker.ResetConsecutiveSuccessCount();
}

protected readonly CircuitBreaker circuitBreaker;
}

public class ClosedState : CircuitBreakerState
{
    public ClosedState(CircuitBreaker circuitBreaker)
        : base(circuitBreaker)
    {
        //重置失败计数器
        circuitBreaker.ResetFailureCount();
    }

public override void ActUponException(Exception e)
{
base.ActUponException(e);
//如果失败次数达到阈值，则切换到断开状态
if (circuitBreaker.FailureThresholdReached())
{
circuitBreaker.MoveToOpenState();
}
}
}

public class OpenState : CircuitBreakerState
{
    private readonly Timer timer;

public OpenState(CircuitBreaker circuitBreaker)
: base(circuitBreaker)
{
timer = new Timer(circuitBreaker.Timeout.TotalMilliseconds);
timer.Elapsed += TimeoutHasBeenReached;
timer.AutoReset = false;
timer.Start();
}

//断开超过设定的阈值，自动切换到半断开状态
private void TimeoutHasBeenReached(object sender, ElapsedEventArgs e)
{
circuitBreaker.MoveToHalfOpenState();
}

public override void ProtectedCodeIsAboutToBeCalled()
{
base.ProtectedCodeIsAboutToBeCalled();
throw new OpenCircuitException();
}
}

public class HalfOpenState : CircuitBreakerState
{
    public HalfOpenState(CircuitBreaker circuitBreaker)
        : base(circuitBreaker)
    {
        //重置连续成功计数
        circuitBreaker.ResetConsecutiveSuccessCount();
    }

public override void ActUponException(Exception e)
{
base.ActUponException(e);
//只要有失败，立即切换到断开模式
circuitBreaker.MoveToOpenState();
}

public override void ProtectedCodeHasBeenCalled()
{
base.ProtectedCodeHasBeenCalled();
//如果连续成功次数达到阈值，切换到闭合状态
if (circuitBreaker.ConsecutiveSuccessThresholdReached())
{
circuitBreaker.MoveToClosedState();
}
}
}

public class CircuitBreaker
{
    private readonly object monitor = new object();
    private CircuitBreakerState state;
    public int FailureCount { get; private set; }
    public int ConsecutiveSuccessCount { get; private set; }
    public int FailureThreshold { get; private set; }
    public int ConsecutiveSuccessThreshold { get; private set; }
    public TimeSpan Timeout { get; private set; }
    public Exception LastException { get; private set; }

public bool IsClosed
{
get { return state is ClosedState; }
}

public bool IsOpen
{
get { return state is OpenState; }
}

public bool IsHalfOpen
{
get { return state is HalfOpenState; }
}

internal void MoveToClosedState()
{
state = new ClosedState(this);
}

internal void MoveToOpenState()
{
state = new OpenState(this);
}

internal void MoveToHalfOpenState()
{
state = new HalfOpenState(this);
}

internal void IncreaseFailureCount(Exception ex)
{
LastException = ex;
FailureCount++;
}

internal void ResetFailureCount()
{
FailureCount = 0;
}

internal bool FailureThresholdReached()
{
return FailureCount >= FailureThreshold;
}

internal void IncreaseSuccessCount()
{
ConsecutiveSuccessCount++;
}

internal void ResetConsecutiveSuccessCount()
{
ConsecutiveSuccessCount = 0;
}

internal bool ConsecutiveSuccessThresholdReached()
{
return ConsecutiveSuccessCount >= ConsecutiveSuccessThreshold;
}

}

public CircuitBreaker(int failedthreshold, int consecutiveSuccessThreshold, TimeSpan timeout)
{
    if (failedthreshold < 1 || consecutiveSuccessThreshold < 1)
    {
        throw new ArgumentOutOfRangeException("threshold", "Threshold should be greater than 0");
    }

if (timeout.TotalMilliseconds < 1)
{
throw new ArgumentOutOfRangeException("timeout", "Timeout should be greater than 0");
}

FailureThreshold = failedthreshold;
ConsecutiveSuccessThreshold = consecutiveSuccessThreshold;
Timeout = timeout;
MoveToClosedState();
}

public void AttemptCall(Action protectedCode)
{
    using (TimedLock.Lock(monitor))
    {
        state.ProtectedCodeIsAboutToBeCalled();
    }

try
{
protectedCode();
}
catch (Exception e)
{
using (TimedLock.Lock(monitor))
{
state.ActUponException(e);
}
throw;
}

using (TimedLock.Lock(monitor))
{
state.ProtectedCodeHasBeenCalled();
}
}

public void Close()
{
    using (TimedLock.Lock(monitor))
    {
        MoveToClosedState();
    }
}

public void Open()
{
using (TimedLock.Lock(monitor))
{
MoveToOpenState();
}
}

private static void CallXAmountOfTimes(Action codeToCall, int timesToCall)
{
    for (int i = 0; i < timesToCall; i++)
    {
        codeToCall();
    }
}

private static void AssertThatExceptionIsThrown<T>(Action code) where T : Exception
{
    try
    {
        code();
    }
    catch (T)
    {
        return;
    }

Assert.Fail("Expected exception of type {0} was not thrown", typeof(T).FullName);
}

[Test]
public void ClosesIfProtectedCodeSucceedsInHalfOpenState()
{
    var stub = new Stub(10);
    //定义熔断器，失败10次进入断开状态
    //5秒后进入半断开状态
    //在半断开状态下，连续成功15次，进入闭合状态
    var circuitBreaker = new CircuitBreaker(10, 15, TimeSpan.FromMilliseconds(5000));
    Assert.That(circuitBreaker.IsClosed);
    //失败10次调用
    CallXAmountOfTimes(() => AssertThatExceptionIsThrown<ApplicationException>(() 
=> circuitBreaker.AttemptCall(stub.DoStuff)), 10);

Assert.AreEqual(10, circuitBreaker.FailureCount);

Assert.That(circuitBreaker.IsOpen);

//等待从Open转到HalfOpen
Thread.Sleep(6000);
Assert.That(circuitBreaker.IsHalfOpen);
//成功调用15次
CallXAmountOfTimes(()=>circuitBreaker.AttemptCall(stub.DoStuff), 15);

Assert.AreEqual(15, circuitBreaker.ConsecutiveSuccessCount);
Assert.AreEqual(0, circuitBreaker.FailureCount);
Assert.That(circuitBreaker.IsClosed);
}