Class CircuitBreakerPolicy

Namespace

Polly.CircuitBreaker

Assembly

Polly.dll

A circuit-breaker policy that can be applied to delegates.

public class CircuitBreakerPolicy : Policy, ISyncPolicy, IAsyncPolicy, ICircuitBreakerPolicy, IsPolicy

Inheritance

object

Policy

CircuitBreakerPolicy

Implements

ISyncPolicy

IAsyncPolicy

ICircuitBreakerPolicy

IsPolicy

Inherited Members

Policy.Bulkhead(int)

Policy.Bulkhead(int, Action<Context>)

Policy.Bulkhead(int, int)

Policy.Bulkhead(int, int, Action<Context>)

Policy.BulkheadAsync(int)

Policy.BulkheadAsync(int, Func<Context, Task>)

Policy.BulkheadAsync(int, int)

Policy.BulkheadAsync(int, int, Func<Context, Task>)

Policy.Bulkhead<TResult>(int)

Policy.Bulkhead<TResult>(int, Action<Context>)

Policy.Bulkhead<TResult>(int, int)

Policy.Bulkhead<TResult>(int, int, Action<Context>)

Policy.BulkheadAsync<TResult>(int)

Policy.BulkheadAsync<TResult>(int, Func<Context, Task>)

Policy.BulkheadAsync<TResult>(int, int)

Policy.BulkheadAsync<TResult>(int, int, Func<Context, Task>)

Policy.Cache(ISyncCacheProvider, TimeSpan, Action<Context, string, Exception>)

Policy.Cache(ISyncCacheProvider, ITtlStrategy, Action<Context, string, Exception>)

Policy.Cache(ISyncCacheProvider, TimeSpan, Func<Context, string>, Action<Context, string, Exception>)

Policy.Cache(ISyncCacheProvider, ITtlStrategy, Func<Context, string>, Action<Context, string, Exception>)

Policy.Cache(ISyncCacheProvider, ITtlStrategy, ICacheKeyStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)

Policy.Cache(ISyncCacheProvider, ITtlStrategy, Func<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)

Policy.CacheAsync(IAsyncCacheProvider, TimeSpan, Action<Context, string, Exception>)

Policy.CacheAsync(IAsyncCacheProvider, ITtlStrategy, Action<Context, string, Exception>)

Policy.CacheAsync(IAsyncCacheProvider, TimeSpan, Func<Context, string>, Action<Context, string, Exception>)

Policy.CacheAsync(IAsyncCacheProvider, ITtlStrategy, Func<Context, string>, Action<Context, string, Exception>)

Policy.CacheAsync(IAsyncCacheProvider, ITtlStrategy, ICacheKeyStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)

Policy.CacheAsync(IAsyncCacheProvider, ITtlStrategy, Func<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider, TimeSpan, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider, ITtlStrategy, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider<TResult>, TimeSpan, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider, TimeSpan, Func<Context, string>, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider, ITtlStrategy, Func<Context, string>, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider<TResult>, TimeSpan, Func<Context, string>, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, Func<Context, string>, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, ICacheKeyStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)

Policy.Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, Func<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider, TimeSpan, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider, ITtlStrategy, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider<TResult>, TimeSpan, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider<TResult>, ITtlStrategy, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider, TimeSpan, Func<Context, string>, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider, ITtlStrategy, Func<Context, string>, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider<TResult>, TimeSpan, Func<Context, string>, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider<TResult>, ITtlStrategy, Func<Context, string>, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider<TResult>, ITtlStrategy, ICacheKeyStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)

Policy.CacheAsync<TResult>(IAsyncCacheProvider<TResult>, ITtlStrategy, Func<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)

Policy.NoOpAsync()

Policy.NoOpAsync<TResult>()

Policy.NoOp<TResult>()

Policy.NoOp()

Policy.Execute(Action)

Policy.Execute(Action, IDictionary<string, object>)

Policy.Execute(Action, Context)

Policy.Execute(Action<Context>, IDictionary<string, object>)

Policy.Execute(Action<Context>, Context)

Policy.Execute(Action<CancellationToken>, CancellationToken)

Policy.Execute(Action<CancellationToken>, IDictionary<string, object>, CancellationToken)

Policy.Execute(Action<CancellationToken>, Context, CancellationToken)

Policy.Execute(Action<Context, CancellationToken>, IDictionary<string, object>, CancellationToken)

Policy.Execute(Action<Context, CancellationToken>, Context, CancellationToken)

Policy.Execute<TResult>(Func<TResult>)

Policy.Execute<TResult>(Func<TResult>, IDictionary<string, object>)

Policy.Execute<TResult>(Func<TResult>, Context)

Policy.Execute<TResult>(Func<Context, TResult>, IDictionary<string, object>)

Policy.Execute<TResult>(Func<Context, TResult>, Context)

Policy.Execute<TResult>(Func<CancellationToken, TResult>, CancellationToken)

Policy.Execute<TResult>(Func<CancellationToken, TResult>, IDictionary<string, object>, CancellationToken)

Policy.Execute<TResult>(Func<CancellationToken, TResult>, Context, CancellationToken)

Policy.Execute<TResult>(Func<Context, CancellationToken, TResult>, IDictionary<string, object>, CancellationToken)

Policy.Execute<TResult>(Func<Context, CancellationToken, TResult>, Context, CancellationToken)

Policy.ExecuteAndCapture(Action)

Policy.ExecuteAndCapture(Action, IDictionary<string, object>)

Policy.ExecuteAndCapture(Action, Context)

Policy.ExecuteAndCapture(Action<Context>, IDictionary<string, object>)

Policy.ExecuteAndCapture(Action<Context>, Context)

Policy.ExecuteAndCapture(Action<CancellationToken>, CancellationToken)

Policy.ExecuteAndCapture(Action<CancellationToken>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAndCapture(Action<CancellationToken>, Context, CancellationToken)

Policy.ExecuteAndCapture(Action<Context, CancellationToken>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAndCapture(Action<Context, CancellationToken>, Context, CancellationToken)

Policy.ExecuteAndCapture<TResult>(Func<TResult>)

Policy.ExecuteAndCapture<TResult>(Func<TResult>, IDictionary<string, object>)

Policy.ExecuteAndCapture<TResult>(Func<TResult>, Context)

Policy.ExecuteAndCapture<TResult>(Func<Context, TResult>, IDictionary<string, object>)

Policy.ExecuteAndCapture<TResult>(Func<Context, TResult>, Context)

Policy.ExecuteAndCapture<TResult>(Func<CancellationToken, TResult>, CancellationToken)

Policy.ExecuteAndCapture<TResult>(Func<CancellationToken, TResult>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAndCapture<TResult>(Func<CancellationToken, TResult>, Context, CancellationToken)

Policy.ExecuteAndCapture<TResult>(Func<Context, CancellationToken, TResult>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAndCapture<TResult>(Func<Context, CancellationToken, TResult>, Context, CancellationToken)

Policy.Handle<TException>()

Policy.Handle<TException>(Func<TException, bool>)

Policy.HandleResult<TResult>(Func<TResult, bool>)

Policy.HandleResult<TResult>(TResult)

Policy.WithPolicyKey(string)

Policy.ExecuteAsync(Func<Task>)

Policy.ExecuteAsync(Func<Task>, IDictionary<string, object>)

Policy.ExecuteAsync(Func<Task>, Context)

Policy.ExecuteAsync(Func<Context, Task>, IDictionary<string, object>)

Policy.ExecuteAsync(Func<Context, Task>, Context)

Policy.ExecuteAsync(Func<Task>, bool)

Policy.ExecuteAsync(Func<Task>, IDictionary<string, object>, bool)

Policy.ExecuteAsync(Func<Task>, Context, bool)

Policy.ExecuteAsync(Func<Context, Task>, IDictionary<string, object>, bool)

Policy.ExecuteAsync(Func<Context, Task>, Context, bool)

Policy.ExecuteAsync(Func<CancellationToken, Task>, CancellationToken)

Policy.ExecuteAsync(Func<CancellationToken, Task>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAsync(Func<CancellationToken, Task>, Context, CancellationToken)

Policy.ExecuteAsync(Func<Context, CancellationToken, Task>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAsync(Func<Context, CancellationToken, Task>, Context, CancellationToken)

Policy.ExecuteAsync(Func<CancellationToken, Task>, CancellationToken, bool)

Policy.ExecuteAsync(Func<CancellationToken, Task>, IDictionary<string, object>, CancellationToken, bool)

Policy.ExecuteAsync(Func<CancellationToken, Task>, Context, CancellationToken, bool)

Policy.ExecuteAsync(Func<Context, CancellationToken, Task>, IDictionary<string, object>, CancellationToken, bool)

Policy.ExecuteAsync(Func<Context, CancellationToken, Task>, Context, CancellationToken, bool)

Policy.ExecuteAsync<TResult>(Func<Task<TResult>>)

Policy.ExecuteAsync<TResult>(Func<Task<TResult>>, IDictionary<string, object>)

Policy.ExecuteAsync<TResult>(Func<Task<TResult>>, Context)

Policy.ExecuteAsync<TResult>(Func<Context, Task<TResult>>, IDictionary<string, object>)

Policy.ExecuteAsync<TResult>(Func<Context, Task<TResult>>, Context)

Policy.ExecuteAsync<TResult>(Func<Task<TResult>>, bool)

Policy.ExecuteAsync<TResult>(Func<Task<TResult>>, IDictionary<string, object>, bool)

Policy.ExecuteAsync<TResult>(Func<Task<TResult>>, Context, bool)

Policy.ExecuteAsync<TResult>(Func<Context, Task<TResult>>, IDictionary<string, object>, bool)

Policy.ExecuteAsync<TResult>(Func<Context, Task<TResult>>, Context, bool)

Policy.ExecuteAsync<TResult>(Func<CancellationToken, Task<TResult>>, CancellationToken)

Policy.ExecuteAsync<TResult>(Func<CancellationToken, Task<TResult>>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAsync<TResult>(Func<CancellationToken, Task<TResult>>, Context, CancellationToken)

Policy.ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken)

Policy.ExecuteAsync<TResult>(Func<CancellationToken, Task<TResult>>, CancellationToken, bool)

Policy.ExecuteAsync<TResult>(Func<CancellationToken, Task<TResult>>, IDictionary<string, object>, CancellationToken, bool)

Policy.ExecuteAsync<TResult>(Func<CancellationToken, Task<TResult>>, Context, CancellationToken, bool)

Policy.ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>>, IDictionary<string, object>, CancellationToken, bool)

Policy.ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync(Func<Task>)

Policy.ExecuteAndCaptureAsync(Func<Task>, IDictionary<string, object>)

Policy.ExecuteAndCaptureAsync(Func<Task>, Context)

Policy.ExecuteAndCaptureAsync(Func<Context, Task>, IDictionary<string, object>)

Policy.ExecuteAndCaptureAsync(Func<Context, Task>, Context)

Policy.ExecuteAndCaptureAsync(Func<Task>, bool)

Policy.ExecuteAndCaptureAsync(Func<Task>, IDictionary<string, object>, bool)

Policy.ExecuteAndCaptureAsync(Func<Task>, Context, bool)

Policy.ExecuteAndCaptureAsync(Func<Context, Task>, IDictionary<string, object>, bool)

Policy.ExecuteAndCaptureAsync(Func<Context, Task>, Context, bool)

Policy.ExecuteAndCaptureAsync(Func<CancellationToken, Task>, CancellationToken)

Policy.ExecuteAndCaptureAsync(Func<CancellationToken, Task>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAndCaptureAsync(Func<CancellationToken, Task>, Context, CancellationToken)

Policy.ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task>, Context, CancellationToken)

Policy.ExecuteAndCaptureAsync(Func<CancellationToken, Task>, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync(Func<CancellationToken, Task>, IDictionary<string, object>, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync(Func<CancellationToken, Task>, Context, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task>, IDictionary<string, object>, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task>, Context, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Task<TResult>>)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Task<TResult>>, IDictionary<string, object>)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Task<TResult>>, Context)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Context, Task<TResult>>, IDictionary<string, object>)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Context, Task<TResult>>, Context)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Task<TResult>>, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Task<TResult>>, IDictionary<string, object>, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Task<TResult>>, Context, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Context, Task<TResult>>, IDictionary<string, object>, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Context, Task<TResult>>, Context, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<CancellationToken, Task<TResult>>, CancellationToken)

Policy.ExecuteAndCaptureAsync<TResult>(Func<CancellationToken, Task<TResult>>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAndCaptureAsync<TResult>(Func<CancellationToken, Task<TResult>>, Context, CancellationToken)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>>, IDictionary<string, object>, CancellationToken)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken)

Policy.ExecuteAndCaptureAsync<TResult>(Func<CancellationToken, Task<TResult>>, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<CancellationToken, Task<TResult>>, IDictionary<string, object>, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<CancellationToken, Task<TResult>>, Context, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>>, IDictionary<string, object>, CancellationToken, bool)

Policy.ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool)

Policy.Timeout(int)

Policy.Timeout(int, TimeoutStrategy)

Policy.Timeout(int, Action<Context, TimeSpan, Task>)

Policy.Timeout(int, TimeoutStrategy, Action<Context, TimeSpan, Task>)

Policy.Timeout(TimeSpan)

Policy.Timeout(TimeSpan, TimeoutStrategy)

Policy.Timeout(TimeSpan, Action<Context, TimeSpan, Task>)

Policy.Timeout(TimeSpan, TimeoutStrategy, Action<Context, TimeSpan, Task>)

Policy.Timeout(Func<TimeSpan>)

Policy.Timeout(Func<TimeSpan>, TimeoutStrategy)

Policy.Timeout(Func<TimeSpan>, Action<Context, TimeSpan, Task>)

Policy.Timeout(Func<TimeSpan>, TimeoutStrategy, Action<Context, TimeSpan, Task>)

Policy.Timeout(Func<Context, TimeSpan>)

Policy.Timeout(Func<Context, TimeSpan>, TimeoutStrategy)

Policy.Timeout(Func<Context, TimeSpan>, Action<Context, TimeSpan, Task>)

Policy.Timeout(Func<Context, TimeSpan>, TimeoutStrategy, Action<Context, TimeSpan, Task>)

Policy.TimeoutAsync(int)

Policy.TimeoutAsync(int, TimeoutStrategy)

Policy.TimeoutAsync(int, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync(int, TimeoutStrategy, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync(TimeSpan)

Policy.TimeoutAsync(TimeSpan, TimeoutStrategy)

Policy.TimeoutAsync(TimeSpan, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync(TimeSpan, TimeoutStrategy, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync(Func<TimeSpan>)

Policy.TimeoutAsync(Func<TimeSpan>, TimeoutStrategy)

Policy.TimeoutAsync(Func<TimeSpan>, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync(Func<TimeSpan>, TimeoutStrategy, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync(Func<Context, TimeSpan>)

Policy.TimeoutAsync(Func<Context, TimeSpan>, TimeoutStrategy)

Policy.TimeoutAsync(Func<Context, TimeSpan>, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync(Func<Context, TimeSpan>, TimeoutStrategy, Func<Context, TimeSpan, Task, Task>)

Policy.Timeout<TResult>(int)

Policy.Timeout<TResult>(int, TimeoutStrategy)

Policy.Timeout<TResult>(int, Action<Context, TimeSpan, Task>)

Policy.Timeout<TResult>(int, TimeoutStrategy, Action<Context, TimeSpan, Task>)

Policy.Timeout<TResult>(TimeSpan)

Policy.Timeout<TResult>(TimeSpan, TimeoutStrategy)

Policy.Timeout<TResult>(TimeSpan, Action<Context, TimeSpan, Task>)

Policy.Timeout<TResult>(TimeSpan, TimeoutStrategy, Action<Context, TimeSpan, Task>)

Policy.Timeout<TResult>(Func<TimeSpan>)

Policy.Timeout<TResult>(Func<TimeSpan>, TimeoutStrategy)

Policy.Timeout<TResult>(Func<TimeSpan>, Action<Context, TimeSpan, Task>)

Policy.Timeout<TResult>(Func<TimeSpan>, TimeoutStrategy, Action<Context, TimeSpan, Task>)

Policy.Timeout<TResult>(Func<Context, TimeSpan>)

Policy.Timeout<TResult>(Func<Context, TimeSpan>, TimeoutStrategy)

Policy.Timeout<TResult>(Func<Context, TimeSpan>, Action<Context, TimeSpan, Task>)

Policy.Timeout<TResult>(Func<Context, TimeSpan>, TimeoutStrategy, Action<Context, TimeSpan, Task>)

Policy.TimeoutAsync<TResult>(int)

Policy.TimeoutAsync<TResult>(int, TimeoutStrategy)

Policy.TimeoutAsync<TResult>(int, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync<TResult>(int, TimeoutStrategy, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync<TResult>(TimeSpan)

Policy.TimeoutAsync<TResult>(TimeSpan, TimeoutStrategy)

Policy.TimeoutAsync<TResult>(TimeSpan, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync<TResult>(TimeSpan, TimeoutStrategy, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync<TResult>(Func<TimeSpan>)

Policy.TimeoutAsync<TResult>(Func<TimeSpan>, TimeoutStrategy)

Policy.TimeoutAsync<TResult>(Func<TimeSpan>, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync<TResult>(Func<TimeSpan>, TimeoutStrategy, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync<TResult>(Func<Context, TimeSpan>)

Policy.TimeoutAsync<TResult>(Func<Context, TimeSpan>, TimeoutStrategy)

Policy.TimeoutAsync<TResult>(Func<Context, TimeSpan>, Func<Context, TimeSpan, Task, Task>)

Policy.TimeoutAsync<TResult>(Func<Context, TimeSpan>, TimeoutStrategy, Func<Context, TimeSpan, Task, Task>)

Policy.Wrap(Policy)

Policy.Wrap<TResult>(Policy<TResult>)

Policy.Wrap(params Policy[])

Policy.Wrap<TResult>(params Policy<TResult>[])

Policy.WrapAsync(Policy)

Policy.WrapAsync<TResult>(Policy<TResult>)

Policy.WrapAsync(params Policy[])

Policy.WrapAsync<TResult>(params Policy<TResult>[])

Policy.PolicyKey

object.GetType()

object.MemberwiseClone()

object.ToString()

object.Equals(object)

object.Equals(object, object)

object.ReferenceEquals(object, object)

object.GetHashCode()

Properties

CircuitState

Gets the state of the underlying circuit.

public CircuitState CircuitState { get; }

Property Value

CircuitState

LastException

Gets the last exception handled by the circuit-breaker. This will be null if no exceptions have been handled by the circuit-breaker since the circuit last closed.

public Exception LastException { get; }

Property Value

Exception

Methods

Isolate()

Isolates (opens) the circuit manually, and holds it in this state until a call to Reset() is made.

public void Isolate()

Reset()

Closes the circuit, and resets any statistics controlling automated circuit-breaking.

public void Reset()