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);
}