Handle faults that may take a variable amount of time to rectify when connecting to a remote service or resource. This pattern can improve the stability and resiliency of an application.
在连接到一个远程服务或资源时，处理故障可能需要一个变量的时间来纠正。这种模式可以提高应用程序的稳定性和弹性。

Context and Problem 上下文与问题

In a distributed environment such as the cloud, where an application performs operations that access remote resources and services, it is possible for these operations to fail due to transient faults such as slow network connections, timeouts, or the resources being overcommitted or temporarily unavailable. These faults typically correct themselves after a short period of time, and a robust cloud application should be prepared to handle them by using a strategy such as that described by the Retry pattern.

在分布式环境中如云，在应用程序执行如访问远程的资源和服务等操作，这些业务由于瞬时故障，如网络连接慢超时失败，或资源投入暂时不可用。这些故障通常是在经过一段短的时间后有恢复正常，一个强大的云应用程序应该使用一种策略来处理这种情况，如通过重试模式描述。

However, there may also be situations where faults are due to unexpected events that are less easily anticipated, and that may take much longer to rectify. These faults can range in severity from a partial loss of connectivity to the complete failure of a service. In these situations it may be pointless for an application to continually retry performing an operation that is unlikely to succeed, and instead the application should quickly accept that the operation has failed and handle this failure accordingly.

然而，也有可能是由于突发事件的情况下，是不容易预料到的，可能需要更长的时间来纠正。这些故障可以从一个服务的完全故障的连接的部分损失的严重程度的范围内。在这种情况下，它可能是毫无意义的一个应用程序不断重试执行的操作是不可能成功的，相反，应用程序应该迅速接受的操作失败，并处理此故障相应。

Additionally, if a service is very busy, failure in one part of the system may lead to cascading failures. For example, an operation that invokes a service could be configured to implement a timeout, and reply with a failure message if the service fails to respond within this period. However, this strategy could cause many concurrent requests to the same operation to be blocked until the timeout period expires. These blocked requests might hold critical system resources such as memory, threads, database connections, and so on. Consequently, these resources could become exhausted, causing failure of other possibly unrelated parts of the system that need to use the same resources. In these situations, it would be preferable for the operation to fail immediately, and only attempt to invoke the service if it is likely to succeed. Note that setting a shorter timeout may help to resolve this problem, but the timeout should not be so short that the operation fails most of the time, even if the request to the service would eventually succeed.

此外，如果一个服务是非常繁忙的，系统中的一个部分的故障可能会导致级联故障。例如，调用服务的操作可以配置为执行超时，如果服务未能在这个时间内响应，将回复一个失败消息。然而，这种策略可能会导致许多并发请求到同一个操作被阻塞，直到超时期限届满。这些阻塞的请求可能会存储关键的系统资源，如内存、线程、数据库连接等。因此，这些资源可能会枯竭，导致其他可能不相关的部分，需要使用相同的资源系统的故障。在这种情况下，它将是优选的操作立即失败，并且只有尝试调用服务，如果它有可能成功。请注意，设置较短的超时可能有助于解决这个问题，但超时不应该如此短，操作失败的大部分时间，即使对服务的请求最终会成功。

Solution 解决方案

The Circuit Breaker pattern can prevent an application repeatedly trying to execute an operation that is likely to fail, allowing it to continue without waiting for the fault to be rectified or wasting CPU cycles while it determines that the fault is long lasting. The Circuit Breaker pattern also enables an application to detect whether the fault has been resolved. If the problem appears to have been rectified, the application can attempt to invoke the operation.

断路器的模式可以防止一个应用程序反复尝试执行一个可能会失败的操作，让它继续不等待故障的纠正或浪费处理器周期，而它决定了故障是长期持久的。断路器的模式也使一个应用程序来检测故障是否已得到解决。如果出现问题，该应用程序可以尝试调用操作。

Note:

The purpose of the Circuit Breaker pattern is different from that of the Retry Pattern. The Retry Pattern enables an application to retry an operation in the expectation that it will succeed. The Circuit Breaker pattern prevents an application from performing an operation that is likely to fail. An application may combine these two patterns by using the Retry pattern to invoke an operation through a circuit breaker. However, the retry logic should be sensitive to any exceptions returned by the circuit breaker and abandon retry attempts if the circuit breaker indicates that a fault is not transient.

断路器模式的目的不同于重试模式。重试模式允许应用程序重试操作，以期望它会成功。断路器的模式可以防止一个应用程序进行操作，可能会失败。一个应用程序可以将这两者结合起来，通过使用重试模式调用一个操作通过一个断路器。然而，重试逻辑应该是敏感的断路器返回的任何异常，并放弃重试尝试，如果断路器表明故障是不暂态。

A circuit breaker acts as a proxy for operations that may fail. The proxy should monitor the number of recent failures that have occurred, and then use this information to decide whether to allow the operation to proceed, or simply return an exception immediately.

断路器作为可能失败的操作的代理。代理应该监测最近发生的故障数，然后使用此信息来决定是否允许该操作进行，或者立即返回一个异常。

•Closed: The request from the application is routed through to the operation. The proxy maintains a count of the number of recent failures, and if the call to the operation is unsuccessful the proxy increments this count. If the number of recent failures exceeds a specified threshold within a given time period, the proxy is placed into the Open state. At this point the proxy starts a timeout timer, and when this timer expires the proxy is placed into the Half-Open state.

关闭：应用程序的请求被路由到操作。代理维护最近失败的数目的计数，如果调用操作失败，则代理递增此计数。如果在给定时间段内，最近的故障数超过了指定的阈值，则该代理被放置在打开状态。在这一点上，代理开始一个超时计时器，当这个计时器过期时，代理被放置到半开放状态。

Note:

The purpose of the timeout timer is to give the system time to rectify the problem that caused the failure before allowing the application to attempt to perform the operation again.

超时计时器的目的是给系统时间来纠正在允许应用程序尝试再次执行操作之前所导致的故障的问题。

• Open: The request from the application fails immediately and an exception is returned to the application.

打开：应用程序的请求失败，立即并一个异常返回到应用程序。

Half-Open: A limited number of requests from the application are allowed to pass through and invoke the operation. If these requests are successful, it is assumed that the fault that was previously causing the failure has been fixed and the circuit breaker switches to the Closed state (the failure counter is reset). If any request fails, the circuit breaker assumes that the fault is still present so it reverts back to the Open state and restarts the timeout timer to give the system a further period of time to recover from the failure.

半开放：应用程序有限的请求可以通过和调用操作。如果这些请求是成功的，它被假定的故障，是以前造成的故障已被固定和断路器开关的闭合状态（故障计数器复位）。如果请求失败，断路器假定故障仍然存在，那么它恢复到打开状态并重新启动超时定时器给系统进一步的时间从故障中恢复。

Note:

The Half-Open state is useful to prevent a recovering service from suddenly being inundated with requests. As a service recovers, it may be able to support a limited volume of requests until the recovery is complete, but while recovery is in progress a flood of work may cause the service to time out or fail again.

半开放状态是有用的，以防止恢复服务突然被淹没的请求。当服务恢复时，它可能会支持有限的请求数量，直到恢复完成，但当恢复是在进行中的工作时，可能会导致服务超时或再次失败。

Figure 1 illustrates the states for one possible implementation of a circuit breaker.

图1说明了一个断路器的一个可能实现的状态。

Figure 1 - Circuit Breaker states 图1 -断路器状态

Note that, in Figure 1, the failure counter used by the Closed state is time-based. It is automatically reset at periodic intervals. This helps to prevent the circuit breaker from entering the Open state if it experiences occasional failures; the failure threshold that trips the circuit breaker into the Open state is only reached when a specified number of failures have occurred during a specified interval. The success counter used by the Half-Open state records the number of successful attempts to invoke the operation. The circuit breaker reverts to the Closed state after a specified number of consecutive operation invocations have been successful. If any invocation fails, the circuit breaker enters the Open state immediately and the success counter will be reset the next time it enters the Half-Open state.

注意，在图1中，由封闭状态的故障计数器时间。它是自动重置周期间隔。这有助于防止断路器进入开放状态，如果它偶尔出现故障，跳闸断路器进入开放状态的故障阈值时，只有达到指定数量的故障发生在指定的时间间隔。半开放状态记录的成功计数器记录成功尝试调用操作的次数。断路器恢复到关闭状态指定数量的连续操作调用后已成功。如果任何调用失败，断路器立即进入打开状态，并在下一次进入半开放状态时，该断路器将被重置。

Note:

How the system recovers is handled externally, possibly by restoring or restarting a failed component or repairing a network connection.

系统如何恢复处理外部，可能通过恢复或重新启动失败的组件或修复网络连接。

Implementing the circuit breaker pattern adds stability and resiliency to a system, offering stability while the system recovers from a failure and minimizing the impact of this failure on performance. It can help to maintain the response time of the system by quickly rejecting a request for an operation that is likely to fail, rather than waiting for the operation to time out (or never return). If the circuit breaker raises an event each time it changes state, this information can be used to monitor the health of the part of the system protected by the circuit breaker, or to alert an administrator when a circuit breaker trips to the Open state.
实现断路器模式增加了系统的稳定性和弹性，提供稳定而系统的破坏和减少这种故障对性能的影响恢复。它可以帮助维持系统的响应时间，快速拒绝一个操作的请求，可能会失败，而不是等待操作超时（或不返回）。如果断路器每一次改变状态，这个信息可以用来监测断路器保护系统的一部分的健康状况，或者当断路器跳闸时，向系统管理员发出警报。

The pattern is customizable and can be adapted according to the nature of the possible failure. For example, you can apply an increasing timeout timer to a circuit breaker. You could place the circuit breaker in the Open state for a few seconds initially, and then if the failure has not been resolved increase the timeout to a few minutes, and so on. In some cases, rather than the Open state returning failure and raising an exception, it could be useful to return a default value that is meaningful to the application.

该模式是可定制的，可以根据可能的故障的性质进行调整。例如，您可以将超时计时器应用于断路器。你可以先将断路器在开状态的几秒钟，然后，如果故障一直没有得到解决，增加超时几分钟，等等。在某些情况下，而不是打开状态返回失败，并引发一个异常，它可能是有用的返回一个默认值，这对应用程序有意义的。

Issues and Considerations 问题和注意事项

•Exception Handling. An application invoking an operation through a circuit breaker must be prepared to handle the exceptions that could be raised if the operation is unavailable. The way in which such exceptions are handled will be application specific. For example, an application could temporarily degrade its functionality, invoke an alternative operation to try to perform the same task or obtain the same data, or report the exception to the user and ask them to try again later.

异常处理。应用程序调用一个操作通过断路器，必须准备好处理可以提出的异常，如果操作不可用。此类异常处理的方式将是应用程序特定的。例如，一个应用程序可能会暂时降低它的功能，调用另一个操作来执行相同的任务，或者获得相同的数据，或者向用户报告异常并要求他们稍后再试。

• Types of Exceptions. A request may fail for a variety of reasons, some of which may indicate a more severe type of failure than others. For example, a request may fail because a remote service has crashed and may take several minutes to recover, or failure could be caused by a timeout due to the service being temporarily overloaded. A circuit breaker may be able to examine the types of exceptions that occur and adjust its strategy depending on the nature of these exceptions. For example, it may require a larger number of timeout exceptions to trip the circuit breaker to the Open state compared to the number of failures due to the service being completely unavailable.

异常类型。一个请求可能会失败，因为有各种各样的原因，其中一些可能表明一个更严重的异常类型。例如，一个请求可能会失败，因为远程服务已经崩溃，可能需要几分钟的时间来恢复，或故障可能是由于临时超载的服务造成的超时。断路器可以检查的类型的异常，发生和调整其策略，根据这些异常的性质。例如，它可能需要一个更大数量的超时异常跳闸断路器的开放状态相比，由于服务是完全不可用的故障数。

• Logging. A circuit breaker should log all failed requests (and possibly successful requests) to enable an administrator to monitor the health of the operation that it encapsulates.

日志记录。断路器应记录所有失败的请求（可能成功的请求）来帮助管理员监控手术所有封装的操作。

• Testing Failed Operations. In the Open state, rather than using a timer to determine when to switch to the Half-Open state, a circuit breaker may instead periodically ping the remote service or resource to determine whether it has become available again. This ping could take the form of an attempt to invoke an operation that had previously failed, or it could use a special operation provided by the remote service specifically for testing the health of the service, as described by the Health Endpoint Monitoring pattern.

• Concurrency. The same circuit breaker could be accessed by a large number of concurrent instances of an application. The implementation should not block concurrent requests or add excessive overhead to each call to an operation.

并发。同样的断路器可以通过大量的并发实例进行访问。执行不应该阻止并发请求或在每次调用操作中添加过多的开销。

• Resource Differentiation. Be careful when using a single circuit breaker for one type of resource if there might be multiple underlying independent providers. For example, in a data store that comprises multiple shards, one shard may be fully accessible while another is experiencing a temporary issue. If the error responses in these scenarios are conflated, an application may attempt to access some shards even when failure is highly likely, while access to other shards may be blocked even though it is likely to succeed.

资源分化。当使用一个单一的断路器一种资源，如果可能有多个潜在的独立供应商。例如，在数据存储，包括多个碎片，一个碎片可以完全访问另一个正在经历一个暂时的问题。如果在这些情况下，错误反应混为一谈，一个应用程序试图访问一些碎片即使失败是很有可能的，而访问其他碎片可能堵塞，即使是有可能成功的。

• Accelerated Circuit Breaking. Sometimes a failure response can contain enough information for the circuit breaker implementation to know it should trip immediately and stay tripped for a minimum amount of time. For example, the error response from a shared resource that is overloaded could indicate that an immediate retry is not recommended and that the application should instead try again in a few minutes time.

加速电路断开。有时一个故障响应可以包含足够的信息，断路器的实施，知道它应该跳闸，并停留在一个最小的时间被绊倒。例如，一个被重载的共享资源的错误响应可以指示立即重试不被推荐，应用程序应该在几分钟时间内再试一次。

Note:

The HTTP protocol defines the “HTTP 503 Service Unavailable” response that can be returned if a requested service is not currently available on a particular web server. This response can include additional information, such as the anticipated duration of the delay.

• Replaying Failed Requests. In the Open state, rather than simply failing quickly, a circuit breaker could also record the details of each request to a journal and arrange for these requests to be replayed when the remote resource or service becomes available.

•重试失败的请求。在开放的状态，而不是简单的不快，断路器还可以记录每个请求的细节，日记和安排这些请求将重播当远程服务或资源可用。

When to Use this Pattern 什么时候使用这种模式

Use this pattern:
•To prevent an application from attempting to invoke a remote service or access a shared resource if this operation is highly likely to fail.

This pattern might not be suitable:
•For handling access to local private resources in an application, such as in-memory data structure. In this environment, using a circuit breaker would simply add overhead to your system.
•As a substitute for handling exceptions in the business logic of your applications.

使用这种模式：

防止一个应用程序试图调用远程服务或访问共享资源，如果这个操作很可能失败。

这种模式可能不适合：

在一个应用程序中处理访问本地的私有资源，例如内存数据结构。在这种环境中，使用断路器会增加系统的开销。

在应用程序的业务逻辑中处理异常的替代品。

Example

In a web application, several of the pages are populated with data retrieved from an external service. If the system implements minimal caching, most hits to each of these pages will cause a round trip to the service. Connections from the web application to the service could be configured with a timeout period (typically 60 seconds), and if the service does not respond in this time the logic in each web page will assume that the service is unavailable and throw an exception.
在一个网络应用程序中，有几个页面被从外部服务中检索到的数据填充。如果该系统实现了最小的缓存，这些页面中的大多数点击将导致一个回合的服务。从网络应用程序到服务的连接可以配置一个超时周期（通常为60秒），如果在这个时间内的服务没有响应，在每个网页中的逻辑将假设该服务是不可用，并抛出异常。

However, if the service fails and the system is very busy, users could be forced to wait for up to 60 seconds before an exception occurs. Eventually resources such as memory, connections, and threads could be exhausted, preventing other users from connecting to the system—even if they are not accessing pages that retrieve data from the service.

但是，如果服务失败，系统非常忙，用户可以在一个异常发生前等待60秒。最终资源，如内存，连接和线程可能会用尽，防止其他用户连接到系统，即使他们不访问的网页，检索数据的服务。

Scaling the system by adding further web servers and implementing load balancing may delay the point at which resources become exhausted, but it will not resolve the issue because user requests will still be unresponsive and all web servers could still eventually run out of resources.

通过添加进一步的网络服务器和实现负载平衡缩放系统可能会延迟资源变得疲惫的点，但它不会解决这个问题，因为用户请求仍然是不响应的，所有的网络服务器仍然可以最终耗尽资源。

Wrapping the logic that connects to the service and retrieves the data in a circuit breaker could help to alleviate the effects of this problem and handle the service failure more elegantly. User requests will still fail, but they will fail more quickly and the resources will not be blocked.

包装的逻辑连接到服务和检索的数据在一个断路器可以帮助缓解这个问题的影响，并处理更优雅的服务故障。用户请求仍然会失败，但他们会更快地失败，资源也不会被阻塞。

The CircuitBreaker class maintains state information about a circuit breaker in an object that implements the ICircuitBreakerStateStore interface shown in the following code.

断路器类保持在实行以下代码中所示的ICircuitBreakerStateStore接口对象的断路器状态信息。

interface ICircuitBreakerStateStore
{
  CircuitBreakerStateEnum State { get; }

  Exception LastException { get; }

  DateTime LastStateChangedDateUtc { get; }

  void Trip(Exception ex);

  void Reset();

  void HalfOpen();

  bool IsClosed { get; }
}

The State property indicates the current state of the circuit breaker, and will be one of the values Open, HalfOpen, or Closed as defined by the CircuitBreakerStateEnum enumeration. The IsClosed property should be true if the circuit breaker is closed, but false if it is open or half-open. The Trip method switches the state of the circuit breaker to the open state and records the exception that caused the change in state, together with the date and time that the exception occurred. The LastException and the LastStateChangedDateUtc properties return this information. The Reset method closes the circuit breaker, and the HalfOpen method sets the circuit breaker to half-open.

State属性表示断路器的当前状态，并将其中一个值，halfopen，或关闭的CircuitBreakerStateEnum枚举定义。如果IsClosed属性是真的，但假如果是开放或半开放。跳闸方法将断路器的状态切换到打开状态，并记录引起状态变化的异常，以及异常发生的日期和时间。的LastException和LastStateChangedDateUtc属性返回此信息。复位方法关闭断路器，和HalfOpen方法设置断路器半开。

The InMemoryCircuitBreakerStateStore class in the example contains an implementation of the ICircuitBreakerStateStore interface. The CircuitBreaker class creates an instance of this class to hold the state of the circuit breaker.

例子中的InMemoryCircuitBreakerStateStore 类包含的ICircuitBreakerStateStore 接口的实现。断路器类创建该类的实例来对断路器的状态。

The ExecuteAction method in the CircuitBreaker class wraps an operation (in the form of an Action delegate) that could fail. When this method runs, it first checks the state of the circuit breaker. If it is closed (the local IsOpen property, which returns true if the circuit breaker is open or half-open, is false) the ExecuteAction method attempts to invoke the Action delegate. If this operation fails, an exception handler executes the TrackException method, which sets the state of the circuit breaker to open by calling the Trip method of the InMemoryCircuitBreakerStateStore object. The following code example highlights this flow.

在CircuitBreaker类的ExecuteAction 方法包装操作（在一个行动代表的形式），可能会失败。当该方法运行时，它首先检查断路器的状态。如果是封闭的（当地IsOpen属性，它返回true，如果断路器是开放或半开放的，是虚假的）的ExecuteAction方法试图调用Action委托。如果操作失败，异常处理程序执行TrackException方法，使断路器的状态通过调用对象的方法InMemoryCircuitBreakerStateStore行程开。下面的代码示例突出了该流程。

public class CircuitBreaker
{
  private readonly ICircuitBreakerStateStore stateStore =
    CircuitBreakerStateStoreFactory.GetCircuitBreakerStateStore();

  private readonly object halfOpenSyncObject = new object ();
  ...
  public bool IsClosed { get { return stateStore.IsClosed; } }

  public bool IsOpen { get { return !IsClosed; } }

  public void ExecuteAction(Action action)
  {
    ...
    if (IsOpen)
    {
      // The circuit breaker is Open.
      ... (see code sample below for details)
    }

    // The circuit breaker is Closed, execute the action.
    try
    {
      action();
    }
    catch (Exception ex)
    {
      // If an exception still occurs here, simply
      // re-trip the breaker immediately.
      this.TrackException(ex);

      // Throw the exception so that the caller can tell
      // the type of exception that was thrown.
      throw;
    }
  }

  private void TrackException(Exception ex)
  {
    // For simplicity in this example, open the circuit breaker on the first exception.
    // In reality this would be more complex. A certain type of exception, such as one
    // that indicates a service is offline, might trip the circuit breaker immediately.
    // Alternatively it may count exceptions locally or across multiple instances and
    // use this value over time, or the exception/success ratio based on the exception
    // types, to open the circuit breaker.
    this.stateStore.Trip(ex);
  }
}

The following example shows the code (omitted from the previous example) that is executed if the circuit breaker is not closed. It first checks if the circuit breaker has been open for a period longer than the time specified by the local OpenToHalfOpenWaitTime field in the CircuitBreaker class. If this is the case, the ExecuteAction method sets the circuit breaker to half-open, then attempts to perform the operation specified by the Action delegate.

下面的例子显示了当电路断路器没有关闭时执行的代码（略）。它首先检查断路器已开放了一段比在断路器类的地方OpenToHalfOpenWaitTime字段中指定的时间更长。如果是这样的话，那executeaction方法设置断路器开一半，然后试图执行的Action委托指定的操作。

If the operation is successful, the circuit breaker is reset to the closed state. If the operation fails, it is tripped back to the open state and the time at which the exception occurred is updated so that the circuit breaker will wait for a further period before attempting to perform the operation again.

如果操作成功，断路器被重置为封闭状态。如果操作失败，则返回打开状态，并将异常发生的时间更新，以便断路器将等待进一步的时间，然后再进行操作。

If the circuit breaker has only been open for a short time, less than the OpenToHalfOpenWaitTime value, the ExecuteAction method simply throws a CircuitBreakerOpenException exception and returns the error that caused the circuit breaker to transition to the open state.

如果断路器只开放很短的时间，比OpenToHalfOpenWaitTime价值的ExecuteAction方法只是抛出一个CircuitBreakerOpenException异常并返回导致断路器的开启状态转换误差。

Additionally, to prevent the circuit breaker from attempting to perform concurrent calls to the operation while it is half-open, it uses a lock. A concurrent attempt to invoke the operation will be handled as if the circuit breaker was open, and it will fail with an exception as described later.

此外，为了防止断路器在半开的时候，试图对其进行并发调用，它使用了一个锁。如果断路器打开，将操作的并发尝试操作将被处理，并且它将在稍后描述的情况下失败。

...
    if (IsOpen)
    {
      // The circuit breaker is Open. Check if the Open timeout has expired.
      // If it has, set the state to HalfOpen. Another approach may be to simply
      // check for the HalfOpen state that had be set by some other operation.
      if (stateStore.LastStateChangedDateUtc + OpenToHalfOpenWaitTime < DateTime.UtcNow)
      {
        // The Open timeout has expired. Allow one operation to execute. Note that, in
        // this example, the circuit breaker is simply set to HalfOpen after being
        // in the Open state for some period of time. An alternative would be to set
        // this using some other approach such as a timer, test method, manually, and
        // so on, and simply check the state here to determine how to handle execution
        // of the action.
        // Limit the number of threads to be executed when the breaker is HalfOpen.
        // An alternative would be to use a more complex approach to determine which
        // threads or how many are allowed to execute, or to execute a simple test
        // method instead.
        bool lockTaken = false;
        try
        {
          Monitor.TryEnter(halfOpenSyncObject, ref lockTaken)
          if (lockTaken)
          {
            // Set the circuit breaker state to HalfOpen.
            stateStore.HalfOpen();

            // Attempt the operation.
            action();

            // If this action succeeds, reset the state and allow other operations.
            // In reality, instead of immediately returning to the Open state, a counter
            // here would record the number of successful operations and return the
            // circuit breaker to the Open state only after a specified number succeed.
            this.stateStore.Reset();
            return;
          }
          catch (Exception ex)
          {
            // If there is still an exception, trip the breaker again immediately.
            this.stateStore.Trip(ex);

            // Throw the exception so that the caller knows which exception occurred.
            throw;
          }
          finally
          {
            if (lockTaken)
            {
              Monitor.Exit(halfOpenSyncObject);
            }
          }
        }
      }
      // The Open timeout has not yet expired. Throw a CircuitBreakerOpen exception to
      // inform the caller that the caller that the call was not actually attempted,
      // and return the most recent exception received.
      throw new CircuitBreakerOpenException(stateStore.LastException);
    }
    ...

To use a CircuitBreaker object to protect an operation, an application creates an instance of the CircuitBreaker class and invokes the ExecuteAction method, specifying the operation to be performed as the parameter. The application should be prepared to catch the CircuitBreakerOpenException exception if the operation fails because the circuit breaker is open. The following code shows an example:

使用断路器保护对象的操作，应用程序创建的CircuitBreaker 的实例并调用ExecuteAction 方法，指定要执行的操作的参数。应用程序应该做好准备，因为如果断路器打开操作失败赶上CircuitBreakerOpenException 例外。下面的代码显示了一个示例：

var breaker = new CircuitBreaker();

try
{
  breaker.ExecuteAction(() =>
  {
    // Operation protected by the circuit breaker.
    ...
  });
}
catch (CircuitBreakerOpenException ex)
{
  // Perform some different action when the breaker is open.
  // Last exception details are in the inner exception.
  ...
}
catch (Exception ex)
{
  ...
}

Related Patterns and Guidance 相关模式和指导

•Retry Pattern. The Retry pattern is a useful adjunct to the Circuit Breaker pattern. It describes how an application can handle anticipated temporary failures when it attempts to connect to a service or network resource by transparently retrying an operation that has previously failed in the expectation that the cause of the failure is transient.
•Health Endpoint Monitoring Pattern. A circuit breaker may be able to test the health of a service by sending a request to an endpoint exposed by the service. The service should return information indicating its status.

重试模式。重试模式是断路器模式的一个有用的辅助工具。它描述了应用程序如何处理预期的暂时的失败时，它试图连接到一个服务或重试操作，透明曾期望失败的原因是短暂的失败的网络资源。

健康端点监测模式。断路器可以通过发送一个请求来测试一个服务的健康状况，该电路断路器可以通过发送一个请求来测试该服务的健康状况。该服务应返回指示其状态的信息。