Rename ResilienceStrategy to ResiliencePipeline

bench/Polly.Core.Benchmarks/BridgeBenchmark.cs

@@ -9,12 +9,12 @@ public class BridgeBenchmark
     public void Setup()
     {
         _policy = Policy.NoOpAsync<string>();
-        _policyWrapped = NullResilienceStrategy<string>.Instance.AsAsyncPolicy();
+        _policyWrapped = NullResiliencePipeline<string>.Instance.AsAsyncPolicy();
     }
 
     [Benchmark(Baseline = true)]
     public Task NoOpAsync() => _policy!.ExecuteAsync(() => Task.FromResult("dummy"));
 
     [Benchmark]
-    public Task NullResilienceStrategy() => _policyWrapped!.ExecuteAsync(() => Task.FromResult("dummy"));
+    public Task NullResiliencePipeline() => _policyWrapped!.ExecuteAsync(() => Task.FromResult("dummy"));
 }

bench/Polly.Core.Benchmarks/CircuitBreakerOpenedBenchmark.cs

@@ -2,15 +2,15 @@ namespace Polly.Core.Benchmarks;
 
 public class CircuitBreakerOpenedBenchmark
 {
-    private ResilienceStrategy? _strategy;
-    private ResilienceStrategy? _strategyHandlesOutcome;
+    private ResiliencePipeline? _strategy;
+    private ResiliencePipeline? _strategyHandlesOutcome;
     private IAsyncPolicy<string>? _policy;
 
     [GlobalSetup]
     public void Setup()
     {
-        _strategyHandlesOutcome = (ResilienceStrategy?)Helper.CreateOpenedCircuitBreaker(PollyVersion.V8, handleOutcome: true);
-        _strategy = (ResilienceStrategy?)Helper.CreateOpenedCircuitBreaker(PollyVersion.V8, handleOutcome: false);
+        _strategyHandlesOutcome = (ResiliencePipeline?)Helper.CreateOpenedCircuitBreaker(PollyVersion.V8, handleOutcome: true);
+        _strategy = (ResiliencePipeline?)Helper.CreateOpenedCircuitBreaker(PollyVersion.V8, handleOutcome: false);
         _policy = (IAsyncPolicy<string>?)Helper.CreateOpenedCircuitBreaker(PollyVersion.V7, handleOutcome: false);
     }
 

bench/Polly.Core.Benchmarks/CreationBenchmark.cs

@@ -15,7 +15,7 @@ public static void Fallback_V7()
     [Benchmark]
     public static void Fallback_V8()
     {
-        new CompositeStrategyBuilder<string>()
+        new ResiliencePipelineBuilder<string>()
             .AddFallback(new()
             {
                 FallbackAction = _ => Outcome.FromResultAsTask("fallback")

bench/Polly.Core.Benchmarks/HedgingBenchmark.cs

@@ -2,7 +2,7 @@ namespace Polly.Core.Benchmarks;
 
 public class HedgingBenchmark
 {
-    private ResilienceStrategy<string>? _strategy;
+    private ResiliencePipeline<string>? _strategy;
 
     [GlobalSetup]
     public void Setup() =>

bench/Polly.Core.Benchmarks/MultipleStrategiesBenchmark.cs

@@ -8,8 +8,8 @@ public class MultipleStrategiesBenchmark
     private object? _strategyV7;
     private object? _strategyV8;
     private object? _strategyTelemetryV8;
-    private ResilienceStrategy? _nonGeneric;
-    private ResilienceStrategy? _nonGenericTelemetry;
+    private ResiliencePipeline? _nonGeneric;
+    private ResiliencePipeline? _nonGenericTelemetry;
 
     [GlobalSetup]
     public void Setup()

bench/Polly.Core.Benchmarks/ResilienceStrategyBenchmark.cs → bench/Polly.Core.Benchmarks/ResiliencePipelineBenchmark.cs

@@ -4,54 +4,54 @@ namespace Polly.Core.Benchmarks;
 
 #pragma warning disable CA1822 // Mark members as static
 
-public class ResilienceStrategyBenchmark
+public class ResiliencePipelineBenchmark
 {
     [Benchmark(Baseline = true)]
     public async ValueTask ExecuteOutcomeAsync()
     {
         var context = ResilienceContextPool.Shared.Get();
-        await NullResilienceStrategy.Instance.ExecuteOutcomeAsync((_, _) => Outcome.FromResultAsTask("dummy"), context, "state").ConfigureAwait(false);
+        await NullResiliencePipeline.Instance.ExecuteOutcomeAsync((_, _) => Outcome.FromResultAsTask("dummy"), context, "state").ConfigureAwait(false);
         ResilienceContextPool.Shared.Return(context);
     }
 
     [Benchmark]
     public async ValueTask ExecuteAsync_ResilienceContextAndState()
     {
         var context = ResilienceContextPool.Shared.Get();
-        await NullResilienceStrategy.Instance.ExecuteAsync((_, _) => new ValueTask<string>("dummy"), context, "state").ConfigureAwait(false);
+        await NullResiliencePipeline.Instance.ExecuteAsync((_, _) => new ValueTask<string>("dummy"), context, "state").ConfigureAwait(false);
         ResilienceContextPool.Shared.Return(context);
     }
 
     [Benchmark]
     public async ValueTask ExecuteAsync_CancellationToken()
     {
-        await NullResilienceStrategy.Instance.ExecuteAsync(_ => new ValueTask<string>("dummy"), CancellationToken.None).ConfigureAwait(false);
+        await NullResiliencePipeline.Instance.ExecuteAsync(_ => new ValueTask<string>("dummy"), CancellationToken.None).ConfigureAwait(false);
     }
 
     [Benchmark]
     public async ValueTask ExecuteAsync_GenericStrategy_CancellationToken()
     {
-        await NullResilienceStrategy<string>.Instance.ExecuteAsync(_ => new ValueTask<string>("dummy"), CancellationToken.None).ConfigureAwait(false);
+        await NullResiliencePipeline<string>.Instance.ExecuteAsync(_ => new ValueTask<string>("dummy"), CancellationToken.None).ConfigureAwait(false);
     }
 
     [Benchmark]
     public void Execute_ResilienceContextAndState()
     {
         var context = ResilienceContextPool.Shared.Get();
-        NullResilienceStrategy.Instance.Execute((_, _) => "dummy", context, "state");
+        NullResiliencePipeline.Instance.Execute((_, _) => "dummy", context, "state");
         ResilienceContextPool.Shared.Return(context);
     }
 
     [Benchmark]
     public void Execute_CancellationToken()
     {
-        NullResilienceStrategy.Instance.Execute(_ => "dummy", CancellationToken.None);
+        NullResiliencePipeline.Instance.Execute(_ => "dummy", CancellationToken.None);
     }
 
     [Benchmark]
     public void Execute_GenericStrategy_CancellationToken()
     {
-        NullResilienceStrategy<string>.Instance.Execute(_ => "dummy", CancellationToken.None);
+        NullResiliencePipeline<string>.Instance.Execute(_ => "dummy", CancellationToken.None);
     }
 
     public class NonGenericStrategy

bench/Polly.Core.Benchmarks/ResiliencePipelineProviderBenchmark.cs

@@ -0,0 +1,24 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Polly.Core.Benchmarks;
+
+public class ResiliencePipelineProviderBenchmark
+{
+    private ResiliencePipelineProvider<string>? _provider;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _provider = new ServiceCollection()
+            .AddResiliencePipeline("dummy", builder => builder.AddTimeout(new TimeoutStrategyOptions()))
+            .AddResiliencePipeline<string, string>("dummy", builder => builder.AddTimeout(new TimeoutStrategyOptions()))
+            .BuildServiceProvider()
+            .GetRequiredService<ResiliencePipelineProvider<string>>();
+    }
+
+    [Benchmark]
+    public void GetPipeline_Ok() => _provider!.GetPipeline("dummy");
+
+    [Benchmark]
+    public void GetPipeline_Generic_Ok() => _provider!.GetPipeline<string>("dummy");
+}

bench/Polly.Core.Benchmarks/TelemetryBenchmark.cs

@@ -6,13 +6,13 @@ namespace Polly.Core.Benchmarks;
 
 public class TelemetryBenchmark
 {
-    private ResilienceStrategy? _strategy;
+    private ResiliencePipeline? _strategy;
     private MeterListener? _meterListener;
 
     [GlobalSetup]
     public void Prepare()
     {
-        _strategy = Build(new CompositeStrategyBuilder());
+        _strategy = Build(new ResiliencePipelineBuilder());
 
         if (Telemetry)
         {
@@ -37,7 +37,7 @@ public async ValueTask Execute()
         ResilienceContextPool.Shared.Return(context);
     }
 
-    private ResilienceStrategy Build(CompositeStrategyBuilder builder)
+    private ResiliencePipeline Build(ResiliencePipelineBuilder builder)
     {
         builder.AddStrategy(context => new TelemetryEventStrategy(context.Telemetry), new EmptyResilienceOptions());
 
@@ -66,7 +66,7 @@ private ResilienceStrategy Build(CompositeStrategyBuilder builder)
         return builder.Build();
     }
 
-    private class TelemetryEventStrategy : NonReactiveResilienceStrategy
+    private class TelemetryEventStrategy : ResilienceStrategy
     {
         private readonly ResilienceStrategyTelemetry _telemetry;
 

bench/Polly.Core.Benchmarks/Utils/EmptyResilienceStrategy.cs

@@ -1,6 +1,6 @@
 namespace Polly.Core.Benchmarks.Utils;
 
-internal class EmptyResilienceStrategy : NonReactiveResilienceStrategy
+internal class EmptyResilienceStrategy : ResilienceStrategy
 {
     protected override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,

bench/Polly.Core.Benchmarks/Utils/Helper.CircuitBreaker.cs

@@ -13,7 +13,7 @@ public static object CreateOpenedCircuitBreaker(PollyVersion version, bool handl
 
         if (version == PollyVersion.V8)
         {
-            var builder = new CompositeStrategyBuilder();
+            var builder = new ResiliencePipelineBuilder();
 
             if (handleOutcome)
             {
@@ -64,7 +64,7 @@ public static object CreateCircuitBreaker(PollyVersion technology)
         };
     }
 
-    private class OutcomeHandlingStrategy : NonReactiveResilienceStrategy
+    private class OutcomeHandlingStrategy : ResilienceStrategy
     {
         protected override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,

bench/Polly.Core.Benchmarks/Utils/Helper.Hedging.cs

@@ -6,7 +6,7 @@ internal static partial class Helper
 {
     public const string Failure = "failure";
 
-    public static ResilienceStrategy<string> CreateHedging()
+    public static ResiliencePipeline<string> CreateHedging()
     {
         return CreateStrategy(builder =>
         {

bench/Polly.Core.Benchmarks/Utils/Helper.MultipleStrategies.cs

@@ -57,9 +57,9 @@ internal static partial class Helper
         _ => throw new NotSupportedException()
     };
 
-    public static ResilienceStrategy CreateNonGenericStrategyPipeline(bool telemetry)
+    public static ResiliencePipeline CreateNonGenericStrategyPipeline(bool telemetry)
     {
-        var builder = new CompositeStrategyBuilder()
+        var builder = new ResiliencePipelineBuilder()
             .AddConcurrencyLimiter(new ConcurrencyLimiterOptions
             {
                 QueueLimit = 10,

bench/Polly.Core.Benchmarks/Utils/Helper.cs

@@ -14,7 +14,7 @@ public static async ValueTask ExecuteAsync(this object obj, PollyVersion version
             case PollyVersion.V8:
                 var context = ResilienceContextPool.Shared.Get();
 
-                await ((ResilienceStrategy<string>)obj).ExecuteOutcomeAsync(
+                await ((ResiliencePipeline<string>)obj).ExecuteOutcomeAsync(
                     static (_, _) => Outcome.FromResultAsTask("dummy"),
                     context,
                     string.Empty).ConfigureAwait(false);
@@ -26,9 +26,9 @@ public static async ValueTask ExecuteAsync(this object obj, PollyVersion version
         throw new NotSupportedException();
     }
 
-    private static ResilienceStrategy<string> CreateStrategy(Action<CompositeStrategyBuilder<string>> configure)
+    private static ResiliencePipeline<string> CreateStrategy(Action<ResiliencePipelineBuilder<string>> configure)
     {
-        var builder = new CompositeStrategyBuilder<string>();
+        var builder = new ResiliencePipelineBuilder<string>();
         configure(builder);
         return builder.Build();
     }

src/Polly.Core/CircuitBreaker/CircuitBreakerCompositeStrategyBuilderExtensions.cs → src/Polly.Core/CircuitBreaker/CircuitBreakerResiliencePipelineBuilderExtensions.cs

@@ -6,9 +6,9 @@
 namespace Polly;
 
 /// <summary>
-/// Circuit breaker strategy extensions for <see cref="CompositeStrategyBuilder"/>.
+/// Circuit breaker strategy extensions for <see cref="ResiliencePipelineBuilder"/>.
 /// </summary>
-public static class CircuitBreakerCompositeStrategyBuilderExtensions
+public static class CircuitBreakerResiliencePipelineBuilderExtensions
 {
     /// <summary>
     /// Add circuit breaker strategy to the builder.
@@ -29,7 +29,7 @@ public static class CircuitBreakerCompositeStrategyBuilderExtensions
         "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code",
         Justification = "All options members preserved.")]
     [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(CircuitBreakerStrategyOptions))]
-    public static CompositeStrategyBuilder AddCircuitBreaker(this CompositeStrategyBuilder builder, CircuitBreakerStrategyOptions options)
+    public static ResiliencePipelineBuilder AddCircuitBreaker(this ResiliencePipelineBuilder builder, CircuitBreakerStrategyOptions options)
     {
         Guard.NotNull(builder);
         Guard.NotNull(options);
@@ -56,8 +56,8 @@ public static CompositeStrategyBuilder AddCircuitBreaker(this CompositeStrategyB
         "Trimming",
         "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code",
         Justification = "All options members preserved.")]
-    public static CompositeStrategyBuilder<TResult> AddCircuitBreaker<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TResult>(
-        this CompositeStrategyBuilder<TResult> builder,
+    public static ResiliencePipelineBuilder<TResult> AddCircuitBreaker<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TResult>(
+        this ResiliencePipelineBuilder<TResult> builder,
         CircuitBreakerStrategyOptions<TResult> options)
     {
         Guard.NotNull(builder);

src/Polly.Core/CircuitBreaker/CircuitBreakerResilienceStrategy.cs

@@ -1,6 +1,6 @@
 namespace Polly.CircuitBreaker;
 
-internal sealed class CircuitBreakerResilienceStrategy<T> : ReactiveResilienceStrategy<T>
+internal sealed class CircuitBreakerResilienceStrategy<T> : ResilienceStrategy<T>
 {
     private readonly Func<OutcomeArguments<T, CircuitBreakerPredicateArguments>, ValueTask<bool>> _handler;
     private readonly CircuitStateController<T> _controller;

src/Polly.Core/CircuitBreaker/CircuitBreakerStateProvider.cs

@@ -24,7 +24,7 @@ internal void Initialize(Func<CircuitState> circuitStateProvider, Func<Outcome<o
     /// </summary>
     /// <remarks>
     /// The initialization happens when the circuit-breaker strategy is attached to this class.
-    /// This happens when the final strategy is created by the <see cref="CompositeStrategyBuilder.Build"/> call.
+    /// This happens when the final strategy is created by the <see cref="ResiliencePipelineBuilder.Build"/> call.
     /// </remarks>
     internal bool IsInitialized => _circuitStateProvider != null;