<PackageReference Include="Polly.Core" Version="8.0.0-alpha.2" />

---

API Differences between 8.0.0-alpha.2 and 8.1.0

326 Additions 90 Removals

Polly

• public static class CircuitBreakerResiliencePipelineBuilderExtensions
• public enum DelayBackoffType
• public static class CircuitBreakerResilienceStrategyBuilderExtensions
  • public static ResilienceStrategyBuilder AddAdvancedCircuitBreaker(this ResilienceStrategyBuilder builder, AdvancedCircuitBreakerStrategyOptions options)
  • public static ResilienceStrategyBuilder<TResult> AddAdvancedCircuitBreaker<TResult>(this ResilienceStrategyBuilder<TResult> builder, AdvancedCircuitBreakerStrategyOptions<TResult> options)
  • public static ResilienceStrategyBuilder<TResult> AddSimpleCircuitBreaker<TResult>(this ResilienceStrategyBuilder<TResult> builder, SimpleCircuitBreakerStrategyOptions<TResult> options)
  • public static ResilienceStrategyBuilder AddSimpleCircuitBreaker(this ResilienceStrategyBuilder builder, SimpleCircuitBreakerStrategyOptions options)
• public abstract class ExecutionRejectedException : Exception
  • protected ExecutionRejectedException(SerializationInfo info, StreamingContext context)
• public static class FallbackResiliencePipelineBuilderExtensions
• public static class FallbackResilienceStrategyBuilderExtensions
  • public static ResilienceStrategyBuilder<TResult> AddFallback<TResult>(this ResilienceStrategyBuilder<TResult> builder, FallbackStrategyOptions<TResult> options)
• public static class HedgingResiliencePipelineBuilderExtensions
• public static class LegacySupport
• public static class HedgingResilienceStrategyBuilderExtensions
  • public static ResilienceStrategyBuilder<TResult> AddHedging<TResult>(this ResilienceStrategyBuilder<TResult> builder, HedgingStrategyOptions<TResult> options)
• public sealed class NullResilienceStrategy : ResilienceStrategy
  • public static readonly NullResilienceStrategy Instance
• public sealed class NullResilienceStrategy<TResult> : ResilienceStrategy<TResult>
  • public static readonly NullResilienceStrategy<TResult> Instance
• public static class Outcome
  • public static ValueTask<Outcome<TResult>> FromExceptionAsValueTask<TResult>(Exception exception)
  • public static ValueTask<Outcome<TResult>> FromExceptionAsTask<TResult>(Exception exception)
  • public static ValueTask<Outcome<TResult>> FromResultAsValueTask<TResult>(TResult value)
  • public static ValueTask<Outcome<TResult>> FromResultAsTask<TResult>(TResult value)
• public struct Outcome<TResult>
  • public bool HasResult { get; }
  • public bool IsVoidResult { get; }
  • public void ThrowIfException()
  • public void EnsureSuccess()
  • public bool TryGetResult(out TResult result)
• public struct OutcomeArguments<TResult, TArgs>
  • public TArgs Arguments { get; }
  • public ResilienceContext Context { get; }
  • public Exception Exception { get; }
  • public Outcome<TResult> Outcome { get; }
  • public TResult Result { get; }
  • public OutcomeArguments(ResilienceContext context, Outcome<TResult> outcome, TArgs arguments)
• public class PredicateBuilder<TResult>
  • public static Func<RetryPredicateArguments<TResult>, ValueTask<bool>> op_Implicit(PredicateBuilder<TResult> builder)
  • public static Func<HedgingPredicateArguments<TResult>, ValueTask<bool>> op_Implicit(PredicateBuilder<TResult> builder)
  • public static Func<FallbackPredicateArguments<TResult>, ValueTask<bool>> op_Implicit(PredicateBuilder<TResult> builder)
  • public static Func<CircuitBreakerPredicateArguments<TResult>, ValueTask<bool>> op_Implicit(PredicateBuilder<TResult> builder)
  • public static Func<OutcomeArguments<TResult, RetryPredicateArguments>, ValueTask<bool>> op_Implicit(PredicateBuilder<TResult> builder)
  • public static Func<OutcomeArguments<TResult, HedgingPredicateArguments>, ValueTask<bool>> op_Implicit(PredicateBuilder<TResult> builder)
  • public static Func<OutcomeArguments<TResult, FallbackPredicateArguments>, ValueTask<bool>> op_Implicit(PredicateBuilder<TResult> builder)
  • public static Func<OutcomeArguments<TResult, CircuitBreakerPredicateArguments>, ValueTask<bool>> op_Implicit(PredicateBuilder<TResult> builder)
  • public Func<OutcomeArguments<TResult, TArgs>, ValueTask<bool>> Build<TArgs>()
• public sealed class ResilienceContext
  • public string OperationKey { get; }
  • public bool IsSynchronous { get; }
  • public bool IsVoid { get; }
  • public IReadOnlyCollection<ResilienceEvent> ResilienceEvents { get; }
  • public Type ResultType { get; }
  • public static ResilienceContext Get()
  • public static void Return(ResilienceContext context)
• public struct ResilienceContextCreationArguments
• public abstract class ResilienceContextPool
• public sealed class ResiliencePipeline
• public sealed class ResiliencePipeline<T>
• public sealed class ResiliencePipelineBuilder : ResiliencePipelineBuilderBase
• public sealed class ResiliencePipelineBuilder<TResult> : ResiliencePipelineBuilderBase
• public abstract class ResiliencePipelineBuilderBase
• public static class ResiliencePipelineBuilderExtensions
• public struct ResiliencePropertyKey<TValue> : IEquatable<ResiliencePropertyKey<TValue>>
  • public static bool op_Equality(ResiliencePropertyKey<TValue> left, ResiliencePropertyKey<TValue> right)
  • public static bool op_Inequality(ResiliencePropertyKey<TValue> left, ResiliencePropertyKey<TValue> right)
  • public bool Equals(ResiliencePropertyKey<TValue> other)
• public abstract class ResilienceStrategy
  • public void Execute<TState>(Action<ResilienceContext, TState> callback, ResilienceContext context, TState state)
  • public void Execute(Action<ResilienceContext> callback, ResilienceContext context)
  • public void Execute<TState>(Action<TState, CancellationToken> callback, TState state, CancellationToken cancellationToken = default)
  • public void Execute(Action<CancellationToken> callback, CancellationToken cancellationToken = default)
  • public void Execute<TState>(Action<TState> callback, TState state)
  • public void Execute(Action callback)
  • public TResult Execute<TResult, TState>(Func<ResilienceContext, TState, TResult> callback, ResilienceContext context, TState state)
  • public TResult Execute<TResult>(Func<ResilienceContext, TResult> callback, ResilienceContext context)
  • public TResult Execute<TResult>(Func<CancellationToken, TResult> callback, CancellationToken cancellationToken = default)
  • public TResult Execute<TResult>(Func<TResult> callback)
  • public TResult Execute<TResult, TState>(Func<TState, TResult> callback, TState state)
  • public TResult Execute<TResult, TState>(Func<TState, CancellationToken, TResult> callback, TState state, CancellationToken cancellationToken = default)
  • public ValueTask ExecuteAsync<TState>(Func<ResilienceContext, TState, ValueTask> callback, ResilienceContext context, TState state)
  • public ValueTask ExecuteAsync(Func<ResilienceContext, ValueTask> callback, ResilienceContext context)
  • public ValueTask ExecuteAsync<TState>(Func<TState, CancellationToken, ValueTask> callback, TState state, CancellationToken cancellationToken = default)
  • public ValueTask ExecuteAsync(Func<CancellationToken, ValueTask> callback, CancellationToken cancellationToken = default)
  • public ValueTask<TResult> ExecuteAsync<TResult, TState>(Func<ResilienceContext, TState, ValueTask<TResult>> callback, ResilienceContext context, TState state)
  • public ValueTask<TResult> ExecuteAsync<TResult>(Func<ResilienceContext, ValueTask<TResult>> callback, ResilienceContext context)
  • public ValueTask<TResult> ExecuteAsync<TResult, TState>(Func<TState, CancellationToken, ValueTask<TResult>> callback, TState state, CancellationToken cancellationToken = default)
  • public ValueTask<TResult> ExecuteAsync<TResult>(Func<CancellationToken, ValueTask<TResult>> callback, CancellationToken cancellationToken = default)
  • public ValueTask<Outcome<TResult>> ExecuteOutcomeAsync<TResult, TState>(Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback, ResilienceContext context, TState state)
• public class ResilienceStrategy<TResult>
  • protected ResilienceStrategy()
  • public TResult Execute<TState>(Func<ResilienceContext, TState, TResult> callback, ResilienceContext context, TState state)
  • public TResult Execute(Func<ResilienceContext, TResult> callback, ResilienceContext context)
  • public TResult Execute(Func<CancellationToken, TResult> callback, CancellationToken cancellationToken = default)
  • public TResult Execute(Func<TResult> callback)
  • public TResult Execute<TState>(Func<TState, TResult> callback, TState state)
  • public TResult Execute<TState>(Func<TState, CancellationToken, TResult> callback, TState state, CancellationToken cancellationToken = default)
  • public ValueTask<TResult> ExecuteAsync<TState>(Func<ResilienceContext, TState, ValueTask<TResult>> callback, ResilienceContext context, TState state)
  • public ValueTask<TResult> ExecuteAsync(Func<ResilienceContext, ValueTask<TResult>> callback, ResilienceContext context)
  • public ValueTask<TResult> ExecuteAsync<TState>(Func<TState, CancellationToken, ValueTask<TResult>> callback, TState state, CancellationToken cancellationToken = default)
  • public ValueTask<TResult> ExecuteAsync(Func<CancellationToken, ValueTask<TResult>> callback, CancellationToken cancellationToken = default)
  • public ValueTask<Outcome<TResult>> ExecuteOutcomeAsync<TState>(Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback, ResilienceContext context, TState state)
• public sealed class ResilienceStrategyBuilder : ResilienceStrategyBuilderBase
  • public ResilienceStrategyBuilder()
  • public ResilienceStrategy Build()
• public sealed class ResilienceStrategyBuilder<TResult> : ResilienceStrategyBuilderBase
  • public ResilienceStrategyBuilder()
  • public ResilienceStrategy<TResult> Build()
• public abstract class ResilienceStrategyBuilderBase
  • public string BuilderName { get; set; }
  • public DiagnosticSource DiagnosticSource { get; set; }
  • public Action<IList<ResilienceStrategy>> OnCreatingStrategy { get; set; }
  • public ResilienceProperties Properties { get; }
• public sealed class ResilienceStrategyBuilderContext
  • public string BuilderName { get; }
  • public ResilienceProperties BuilderProperties { get; }
  • public string StrategyName { get; }
  • public string StrategyType { get; }
  • public ResilienceStrategyTelemetry Telemetry { get; }
• public static class ResilienceStrategyBuilderExtensions
  • public static TBuilder AddStrategy<TBuilder>(this TBuilder builder, ResilienceStrategy strategy) where TBuilder : ResilienceStrategyBuilderBase
  • public static TBuilder AddStrategy<TBuilder>(this TBuilder builder, Func<ResilienceStrategyBuilderContext, ResilienceStrategy> factory, ResilienceStrategyOptions options) where TBuilder : ResilienceStrategyBuilderBase
• public abstract class ResilienceStrategyOptions
  • public string Name { get; set; }
  • public string StrategyName { get; set; }
  • public abstract string StrategyType { get; }
• public static class RetryResiliencePipelineBuilderExtensions
• public sealed class StrategyBuilderContext
• public static class RetryResilienceStrategyBuilderExtensions
  • public static ResilienceStrategyBuilder AddRetry(this ResilienceStrategyBuilder builder, RetryStrategyOptions options)
  • public static ResilienceStrategyBuilder<TResult> AddRetry<TResult>(this ResilienceStrategyBuilder<TResult> builder, RetryStrategyOptions<TResult> options)
• public static class TimeoutResiliencePipelineBuilderExtensions
• public static class TimeoutResilienceStrategyBuilderExtensions
  • public static TBuilder AddTimeout<TBuilder>(this TBuilder builder, TimeSpan timeout) where TBuilder : ResilienceStrategyBuilderBase
  • public static TBuilder AddTimeout<TBuilder>(this TBuilder builder, TimeoutStrategyOptions options) where TBuilder : ResilienceStrategyBuilderBase

Polly.CircuitBreaker

• public class AdvancedCircuitBreakerStrategyOptions : AdvancedCircuitBreakerStrategyOptions<object>
  • public AdvancedCircuitBreakerStrategyOptions()
• public class AdvancedCircuitBreakerStrategyOptions<TResult> : CircuitBreakerStrategyOptions<TResult>
  • public double FailureThreshold { get; set; }
  • public int MinimumThroughput { get; set; }
  • public TimeSpan SamplingDuration { get; set; }
  • public AdvancedCircuitBreakerStrategyOptions()
• public class BrokenCircuitException : ExecutionRejectedException
  • protected BrokenCircuitException(SerializationInfo info, StreamingContext context)
• public class BrokenCircuitException<TResult> : BrokenCircuitException
  • public TResult Result { get; }
  • public BrokenCircuitException(TResult result)
  • public BrokenCircuitException(string message, TResult result)
  • public BrokenCircuitException(string message, Exception inner, TResult result)
• public sealed class CircuitBreakerManualControl : IDisposable
  • public CircuitBreakerManualControl(bool isIsolated)
  • public void Dispose()
• public struct CircuitBreakerPredicateArguments<TResult> : IOutcomeArguments<TResult>
• public struct CircuitBreakerPredicateArguments : IEquatable<CircuitBreakerPredicateArguments>
  • public CircuitBreakerPredicateArguments()
  • public static bool op_Equality(CircuitBreakerPredicateArguments left, CircuitBreakerPredicateArguments right)
  • public static bool op_Inequality(CircuitBreakerPredicateArguments left, CircuitBreakerPredicateArguments right)
  • public bool Equals(CircuitBreakerPredicateArguments other)
• public sealed class CircuitBreakerStateProvider
  • public Outcome<object>? LastHandledOutcome { get; }
• public class CircuitBreakerStrategyOptions : CircuitBreakerStrategyOptions<object>
• public abstract class CircuitBreakerStrategyOptions<TResult> : ResilienceStrategyOptions
  • public double FailureRatio { get; set; }
  • public int MinimumThroughput { get; set; }
  • public Func<OnCircuitClosedArguments<TResult>, ValueTask> OnClosed { get; set; }
  • public Func<OutcomeArguments<TResult, OnCircuitClosedArguments>, ValueTask> OnClosed { get; set; }
  • public Func<OnCircuitOpenedArguments<TResult>, ValueTask> OnOpened { get; set; }
  • public TimeSpan SamplingDuration { get; set; }
  • public Func<CircuitBreakerPredicateArguments<TResult>, ValueTask<bool>> ShouldHandle { get; set; }
  • public Func<OutcomeArguments<TResult, OnCircuitOpenedArguments>, ValueTask> OnOpened { get; set; }
  • public Func<OutcomeArguments<TResult, CircuitBreakerPredicateArguments>, ValueTask<bool>> ShouldHandle { get; set; }
• public class IsolatedCircuitException : BrokenCircuitException
  • protected IsolatedCircuitException(SerializationInfo info, StreamingContext context)
• public struct OnCircuitClosedArguments<TResult> : IOutcomeArguments<TResult>
• public class OnCircuitClosedArguments : IEquatable<OnCircuitClosedArguments>
  • protected virtual Type EqualityContract { get; }
  • public bool IsManual { get; set; }
  • public OnCircuitClosedArguments(bool IsManual)
  • protected OnCircuitClosedArguments(OnCircuitClosedArguments original)
  • public static bool op_Equality(OnCircuitClosedArguments left, OnCircuitClosedArguments right)
  • public static bool op_Inequality(OnCircuitClosedArguments left, OnCircuitClosedArguments right)
  • public virtual OnCircuitClosedArguments <Clone>$()
  • public void Deconstruct(out bool IsManual)
  • public virtual bool Equals(OnCircuitClosedArguments other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public class OnCircuitHalfOpenedArguments : IEquatable<OnCircuitHalfOpenedArguments>
  • public ResilienceContext Context { get; }
  • public OnCircuitHalfOpenedArguments(ResilienceContext context)
  • protected virtual Type EqualityContract { get; }
  • public OnCircuitHalfOpenedArguments()
  • protected OnCircuitHalfOpenedArguments(OnCircuitHalfOpenedArguments original)
  • public static bool op_Equality(OnCircuitHalfOpenedArguments left, OnCircuitHalfOpenedArguments right)
  • public static bool op_Inequality(OnCircuitHalfOpenedArguments left, OnCircuitHalfOpenedArguments right)
  • public virtual OnCircuitHalfOpenedArguments <Clone>$()
  • public virtual bool Equals(OnCircuitHalfOpenedArguments other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public struct OnCircuitOpenedArguments<TResult> : IOutcomeArguments<TResult>
• public class OnCircuitOpenedArguments : IEquatable<OnCircuitOpenedArguments>
  • public TimeSpan BreakDuration { get; set; }
  • protected virtual Type EqualityContract { get; }
  • public bool IsManual { get; set; }
  • public OnCircuitOpenedArguments(TimeSpan BreakDuration, bool IsManual)
  • protected OnCircuitOpenedArguments(OnCircuitOpenedArguments original)
  • public static bool op_Equality(OnCircuitOpenedArguments left, OnCircuitOpenedArguments right)
  • public static bool op_Inequality(OnCircuitOpenedArguments left, OnCircuitOpenedArguments right)
  • public virtual OnCircuitOpenedArguments <Clone>$()
  • public void Deconstruct(out TimeSpan BreakDuration, out bool IsManual)
  • public virtual bool Equals(OnCircuitOpenedArguments other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public class SimpleCircuitBreakerStrategyOptions : SimpleCircuitBreakerStrategyOptions<object>
  • public SimpleCircuitBreakerStrategyOptions()
• public class SimpleCircuitBreakerStrategyOptions<TResult> : CircuitBreakerStrategyOptions<TResult>
  • public int FailureThreshold { get; set; }
  • public SimpleCircuitBreakerStrategyOptions()

Polly.Fallback

• public struct FallbackActionArguments<TResult> : IOutcomeArguments<TResult>
• public struct FallbackPredicateArguments<TResult> : IOutcomeArguments<TResult>
• public struct FallbackPredicateArguments : IEquatable<FallbackPredicateArguments>
  • public FallbackPredicateArguments()
  • public static bool op_Equality(FallbackPredicateArguments left, FallbackPredicateArguments right)
  • public static bool op_Inequality(FallbackPredicateArguments left, FallbackPredicateArguments right)
  • public bool Equals(FallbackPredicateArguments other)
• public class FallbackStrategyOptions<TResult> : ResilienceStrategyOptions
  • public Func<FallbackActionArguments<TResult>, ValueTask<Outcome<TResult>>> FallbackAction { get; set; }
  • public Func<OnFallbackArguments<TResult>, ValueTask> OnFallback { get; set; }
  • public Func<FallbackPredicateArguments<TResult>, ValueTask<bool>> ShouldHandle { get; set; }
  • public Func<OutcomeArguments<TResult, FallbackPredicateArguments>, ValueTask<Outcome<TResult>>> FallbackAction { get; set; }
  • public Func<OutcomeArguments<TResult, OnFallbackArguments>, ValueTask> OnFallback { get; set; }
  • public Func<OutcomeArguments<TResult, FallbackPredicateArguments>, ValueTask<bool>> ShouldHandle { get; set; }
• public struct OnFallbackArguments<TResult> : IOutcomeArguments<TResult>
• public class OnFallbackArguments : IEquatable<OnFallbackArguments>
  • protected virtual Type EqualityContract { get; }
  • public OnFallbackArguments()
  • protected OnFallbackArguments(OnFallbackArguments original)
  • public static bool op_Equality(OnFallbackArguments left, OnFallbackArguments right)
  • public static bool op_Inequality(OnFallbackArguments left, OnFallbackArguments right)
  • public virtual OnFallbackArguments <Clone>$()
  • public virtual bool Equals(OnFallbackArguments other)
  • protected virtual bool PrintMembers(StringBuilder builder)

Polly.Hedging

• public struct HedgingActionGeneratorArguments<TResult> : IEquatable<HedgingActionGeneratorArguments<TResult>>
  • public int AttemptNumber { get; }
  • public int Attempt { get; set; }
  • public static bool op_Equality(HedgingActionGeneratorArguments<TResult> left, HedgingActionGeneratorArguments<TResult> right)
  • public static bool op_Inequality(HedgingActionGeneratorArguments<TResult> left, HedgingActionGeneratorArguments<TResult> right)
  • public void Deconstruct(out ResilienceContext PrimaryContext, out ResilienceContext ActionContext, out int Attempt, out Func Callback)
  • public bool Equals(HedgingActionGeneratorArguments<TResult> other)
• public struct HedgingDelayGeneratorArguments
• public struct HedgingPredicateArguments<TResult> : IOutcomeArguments<TResult>
• public struct HedgingDelayArguments : IEquatable<HedgingDelayArguments>
  • public int Attempt { get; set; }
  • public ResilienceContext Context { get; set; }
  • public HedgingDelayArguments(ResilienceContext Context, int Attempt)
  • public static bool op_Equality(HedgingDelayArguments left, HedgingDelayArguments right)
  • public static bool op_Inequality(HedgingDelayArguments left, HedgingDelayArguments right)
  • public void Deconstruct(out ResilienceContext Context, out int Attempt)
  • public bool Equals(HedgingDelayArguments other)
• public struct HedgingPredicateArguments : IEquatable<HedgingPredicateArguments>
  • public HedgingPredicateArguments()
  • public static bool op_Equality(HedgingPredicateArguments left, HedgingPredicateArguments right)
  • public static bool op_Inequality(HedgingPredicateArguments left, HedgingPredicateArguments right)
  • public bool Equals(HedgingPredicateArguments other)
• public class HedgingStrategyOptions<TResult> : ResilienceStrategyOptions
  • public Func<HedgingActionGeneratorArguments<TResult>, Func<ValueTask<Outcome<TResult>>>> ActionGenerator { get; set; }
  • public TimeSpan Delay { get; set; }
  • public Func<HedgingDelayGeneratorArguments, ValueTask<TimeSpan>> DelayGenerator { get; set; }
  • public Func<HedgingActionGeneratorArguments<TResult>, Func<ValueTask<Outcome<TResult>>>> HedgingActionGenerator { get; set; }
  • public TimeSpan HedgingDelay { get; set; }
  • public Func<HedgingDelayArguments, ValueTask<TimeSpan>> HedgingDelayGenerator { get; set; }
  • public Func<OnHedgingArguments<TResult>, ValueTask> OnHedging { get; set; }
  • public Func<HedgingPredicateArguments<TResult>, ValueTask<bool>> ShouldHandle { get; set; }
  • public Func<OutcomeArguments<TResult, OnHedgingArguments>, ValueTask> OnHedging { get; set; }
  • public Func<OutcomeArguments<TResult, HedgingPredicateArguments>, ValueTask<bool>> ShouldHandle { get; set; }
• public struct OnHedgingArguments<TResult>
• public class OnHedgingArguments : IEquatable<OnHedgingArguments>
  • public int Attempt { get; set; }
  • protected virtual Type EqualityContract { get; }
  • public TimeSpan ExecutionTime { get; set; }
  • public bool HasOutcome { get; set; }
  • public OnHedgingArguments(int Attempt, bool HasOutcome, TimeSpan ExecutionTime)
  • protected OnHedgingArguments(OnHedgingArguments original)
  • public static bool op_Equality(OnHedgingArguments left, OnHedgingArguments right)
  • public static bool op_Inequality(OnHedgingArguments left, OnHedgingArguments right)
  • public virtual OnHedgingArguments <Clone>$()
  • public void Deconstruct(out int Attempt, out bool HasOutcome, out TimeSpan ExecutionTime)
  • public virtual bool Equals(OnHedgingArguments other)
  • protected virtual bool PrintMembers(StringBuilder builder)

Polly.Registry

• public class ConfigureBuilderContext<TKey>
  • public TKey PipelineKey { get; }
  • public void AddReloadToken(CancellationToken cancellationToken)
  • public void OnPipelineDisposed(Action callback)
  • public string BuilderName { get; }
  • public TKey StrategyKey { get; }
  • public string StrategyKeyString { get; }
  • public void EnableReloads(Func<CancellationToken> reloadTokenProducer)
• public abstract class ResiliencePipelineProvider<TKey>
• public sealed class ResiliencePipelineRegistry<TKey> : ResiliencePipelineProvider<TKey>, IDisposable, IAsyncDisposable
• public class ResiliencePipelineRegistryOptions<TKey>
• public abstract class ResilienceStrategyProvider<TKey>
  • protected ResilienceStrategyProvider()
  • public virtual ResilienceStrategy GetStrategy(TKey key)
  • public virtual ResilienceStrategy<TResult> GetStrategy<TResult>(TKey key)
  • public abstract bool TryGetStrategy(TKey key, out ResilienceStrategy strategy)
  • public abstract bool TryGetStrategy<TResult>(TKey key, out ResilienceStrategy strategy)
• public sealed class ResilienceStrategyRegistry<TKey> : ResilienceStrategyProvider<TKey>
  • public ResilienceStrategyRegistry()
  • public ResilienceStrategyRegistry(ResilienceStrategyRegistryOptions<TKey> options)
  • public void ClearStrategies()
  • public void ClearStrategies<TResult>()
  • public bool RemoveBuilder(TKey key)
  • public bool RemoveBuilder<TResult>(TKey key)
  • public bool RemoveStrategy(TKey key)
  • public bool RemoveStrategy<TResult>(TKey key)
  • public bool TryAddBuilder(TKey key, Action<ResilienceStrategyBuilder, ConfigureBuilderContext<TKey>> configure)
  • public bool TryAddBuilder<TResult>(TKey key, Action<ResilienceStrategyBuilder<TResult>, ConfigureBuilderContext<TKey>> configure)
  • public bool TryAddStrategy(TKey key, ResilienceStrategy strategy)
  • public bool TryAddStrategy<TResult>(TKey key, ResilienceStrategy<TResult> strategy)
• public class ResilienceStrategyRegistryOptions<TKey>
  • public IEqualityComparer<TKey> BuilderComparer { get; set; }
  • public Func<ResilienceStrategyBuilder> BuilderFactory { get; set; }
  • public Func<TKey, string> BuilderNameFormatter { get; set; }
  • public IEqualityComparer<TKey> StrategyComparer { get; set; }
  • public Func<TKey, string> StrategyKeyFormatter { get; set; }
  • public ResilienceStrategyRegistryOptions()

Polly.Retry

• public struct OnRetryArguments<TResult> : IOutcomeArguments<TResult>
• public struct RetryDelayGeneratorArguments<TResult>
• public struct RetryPredicateArguments<TResult> : IOutcomeArguments<TResult>
• public class OnRetryArguments : IEquatable<OnRetryArguments>
  • public int Attempt { get; set; }
  • protected virtual Type EqualityContract { get; }
  • public TimeSpan ExecutionTime { get; set; }
  • public TimeSpan RetryDelay { get; set; }
  • public OnRetryArguments(int Attempt, TimeSpan RetryDelay, TimeSpan ExecutionTime)
  • protected OnRetryArguments(OnRetryArguments original)
  • public static bool op_Equality(OnRetryArguments left, OnRetryArguments right)
  • public static bool op_Inequality(OnRetryArguments left, OnRetryArguments right)
  • public virtual OnRetryArguments <Clone>$()
  • public void Deconstruct(out int Attempt, out TimeSpan RetryDelay, out TimeSpan ExecutionTime)
  • public virtual bool Equals(OnRetryArguments other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public enum RetryBackoffType
  • Constant = 0
  • Exponential = 2
  • ExponentialWithJitter = 3
  • Linear = 1
• public struct RetryDelayArguments : IEquatable<RetryDelayArguments>
  • public int Attempt { get; set; }
  • public TimeSpan DelayHint { get; set; }
  • public RetryDelayArguments(int Attempt, TimeSpan DelayHint)
  • public static bool op_Equality(RetryDelayArguments left, RetryDelayArguments right)
  • public static bool op_Inequality(RetryDelayArguments left, RetryDelayArguments right)
  • public void Deconstruct(out int Attempt, out TimeSpan DelayHint)
  • public bool Equals(RetryDelayArguments other)
• public struct RetryPredicateArguments : IEquatable<RetryPredicateArguments>
  • public int Attempt { get; set; }
  • public RetryPredicateArguments(int Attempt)
  • public static bool op_Equality(RetryPredicateArguments left, RetryPredicateArguments right)
  • public static bool op_Inequality(RetryPredicateArguments left, RetryPredicateArguments right)
  • public void Deconstruct(out int Attempt)
  • public bool Equals(RetryPredicateArguments other)
• public class RetryStrategyOptions : RetryStrategyOptions<object>
  • public const int InfiniteRetryCount = -1
• public class RetryStrategyOptions<TResult> : ResilienceStrategyOptions
  • public DelayBackoffType BackoffType { get; set; }
  • public TimeSpan Delay { get; set; }
  • public Func<RetryDelayGeneratorArguments<TResult>, ValueTask<TimeSpan?>> DelayGenerator { get; set; }
  • public TimeSpan? MaxDelay { get; set; }
  • public int MaxRetryAttempts { get; set; }
  • public Func<OnRetryArguments<TResult>, ValueTask> OnRetry { get; set; }
  • public Func<double> Randomizer { get; set; }
  • public Func<RetryPredicateArguments<TResult>, ValueTask<bool>> ShouldHandle { get; set; }
  • public bool UseJitter { get; set; }
  • public RetryBackoffType BackoffType { get; set; }
  • public TimeSpan BaseDelay { get; set; }
  • public Func<OutcomeArguments<TResult, OnRetryArguments>, ValueTask> OnRetry { get; set; }
  • public int RetryCount { get; set; }
  • public Func<OutcomeArguments<TResult, RetryDelayArguments>, ValueTask<TimeSpan>> RetryDelayGenerator { get; set; }
  • public Func<OutcomeArguments<TResult, RetryPredicateArguments>, ValueTask<bool>> ShouldHandle { get; set; }

Polly.Telemetry

• public class ExecutionAttemptArguments
  • public int AttemptNumber { get; }
  • public TimeSpan Duration { get; }
  • public int Attempt { get; }
  • public TimeSpan ExecutionTime { get; }
• public struct PipelineExecutedArguments
• public struct PipelineExecutingArguments
• public struct ResilienceEvent : IEquatable<ResilienceEvent>
  • public ResilienceEventSeverity Severity { get; }
  • public ResilienceEvent(ResilienceEventSeverity severity, string eventName)
  • public ResilienceEvent(string EventName)
  • public static bool op_Equality(ResilienceEvent left, ResilienceEvent right)
  • public static bool op_Inequality(ResilienceEvent left, ResilienceEvent right)
  • public void Deconstruct(out string EventName)
  • public bool Equals(ResilienceEvent other)
• public enum ResilienceEventSeverity
• public sealed class ResilienceStrategyTelemetry
  • public void Report<TArgs>(ResilienceEvent resilienceEvent, ResilienceContext context, TArgs args)
  • public void Report<TArgs, TResult>(ResilienceEvent resilienceEvent, ResilienceContext context, Outcome<TResult> outcome, TArgs args)
  • public bool IsEnabled { get; }
  • public void Report<TArgs>(string eventName, ResilienceContext context, TArgs args)
  • public void Report<TArgs, TResult>(string eventName, OutcomeArguments<TResult, TArgs> args)
• public sealed class ResilienceTelemetrySource : IEquatable<ResilienceTelemetrySource>
  • public string PipelineInstanceName { get; }
  • public string PipelineName { get; }
  • public string BuilderName { get; set; }
  • public ResilienceProperties BuilderProperties { get; set; }
  • public ResilienceTelemetrySource(string pipelineName, string pipelineInstanceName, string strategyName)
  • public string StrategyType { get; set; }
  • public ResilienceTelemetrySource(string BuilderName, ResilienceProperties BuilderProperties, string StrategyName, string StrategyType)
  • public static bool op_Equality(ResilienceTelemetrySource left, ResilienceTelemetrySource right)
  • public static bool op_Inequality(ResilienceTelemetrySource left, ResilienceTelemetrySource right)
  • public ResilienceTelemetrySource <Clone>$()
  • public void Deconstruct(out string BuilderName, out ResilienceProperties BuilderProperties, out string StrategyName, out string StrategyType)
  • public bool Equals(ResilienceTelemetrySource other)
• public struct TelemetryEventArguments<TResult, TArgs>
• public abstract class TelemetryListener
• public sealed class TelemetryEventArguments : IEquatable<TelemetryEventArguments>
  • public object Arguments { get; }
  • public ResilienceContext Context { get; }
  • public string EventName { get; }
  • public Outcome<object>? Outcome { get; }
  • public ResilienceTelemetrySource Source { get; }
  • public static bool op_Equality(TelemetryEventArguments left, TelemetryEventArguments right)
  • public static bool op_Inequality(TelemetryEventArguments left, TelemetryEventArguments right)
  • public TelemetryEventArguments <Clone>$()
  • public bool Equals(TelemetryEventArguments other)

Polly.Timeout

• public class OnTimeoutArguments : IEquatable<OnTimeoutArguments>
  • protected virtual Type EqualityContract { get; }
  • public Exception Exception { get; set; }
  • public OnTimeoutArguments(ResilienceContext context, TimeSpan timeout)
  • public OnTimeoutArguments(ResilienceContext Context, Exception Exception, TimeSpan Timeout)
  • protected OnTimeoutArguments(OnTimeoutArguments original)
  • public static bool op_Equality(OnTimeoutArguments left, OnTimeoutArguments right)
  • public static bool op_Inequality(OnTimeoutArguments left, OnTimeoutArguments right)
  • public virtual OnTimeoutArguments <Clone>$()
  • public void Deconstruct(out ResilienceContext Context, out Exception Exception, out TimeSpan Timeout)
  • public virtual bool Equals(OnTimeoutArguments other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public struct TimeoutGeneratorArguments : IEquatable<TimeoutGeneratorArguments>
  • public static bool op_Equality(TimeoutGeneratorArguments left, TimeoutGeneratorArguments right)
  • public static bool op_Inequality(TimeoutGeneratorArguments left, TimeoutGeneratorArguments right)
  • public void Deconstruct(out ResilienceContext Context)
  • public bool Equals(TimeoutGeneratorArguments other)

Polly.Utils

• public static class LegacySupport
  • public static void SetProperties(this ResilienceProperties resilienceProperties, IDictionary<string, object> properties, out IDictionary oldProperties)