Class BulkheadPolicy

Namespace

Polly.Bulkhead

Assembly

Polly.dll

A bulkhead-isolation policy which can be applied to delegates.

public class BulkheadPolicy : Policy, ISyncPolicy, IAsyncPolicy, IBulkheadPolicy, IsPolicy, IDisposable

Inheritance

object

Policy

BulkheadPolicy

Implements

ISyncPolicy

IAsyncPolicy

IBulkheadPolicy

IsPolicy

IDisposable

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

BulkheadAvailableCount

Gets the number of slots currently available for executing actions through the bulkhead.

public int BulkheadAvailableCount { get; }

Property Value

int

QueueAvailableCount

Gets the number of slots currently available for queuing actions for execution through the bulkhead.

public int QueueAvailableCount { get; }

Property Value

int

Methods

Dispose()

Disposes of the BulkheadPolicy, allowing it to dispose its internal resources.
Only call Dispose() on a BulkheadPolicy after all actions executed through the policy have completed. If actions are still executing through the policy when Dispose() is called, an ObjectDisposedException may be thrown on the actions' threads when those actions complete.

public void Dispose()