Cleanup OutcomeResilienceStrategy

Author: martintmk

src/Polly.Core/CircuitBreaker/CircuitBreakerResilienceStrategy.cs

@@ -9,9 +9,7 @@ public CircuitBreakerResilienceStrategy(
         Func<OutcomeArguments<T, CircuitBreakerPredicateArguments>, ValueTask<bool>> handler,
         CircuitStateController<T> controller,
         CircuitBreakerStateProvider? stateProvider,
-        CircuitBreakerManualControl? manualControl,
-        bool isGeneric)
-        : base(isGeneric)
+        CircuitBreakerManualControl? manualControl)
     {
         _handler = handler;
         _controller = controller;
@@ -23,7 +21,7 @@ public CircuitBreakerResilienceStrategy(
             _controller.Dispose);
     }
 
-    protected override async ValueTask<Outcome<T>> ExecuteCallbackAsync<TState>(Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback, ResilienceContext context, TState state)
+    protected override async ValueTask<Outcome<T>> ExecuteCore<TState>(Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback, ResilienceContext context, TState state)
     {
         if (await _controller.OnActionPreExecuteAsync(context).ConfigureAwait(context.ContinueOnCapturedContext) is Outcome<T> outcome)
         {

src/Polly.Core/CircuitBreaker/CircuitBreakerResilienceStrategyBuilderExtensions.cs

@@ -156,8 +156,7 @@ private static TBuilder AddSimpleCircuitBreakerCore<TBuilder, TResult>(this TBui
             options.ShouldHandle!,
             controller,
             options.StateProvider,
-            options.ManualControl,
-            context.IsGenericBuilder);
+            options.ManualControl);
     }
 }
 

src/Polly.Core/Fallback/FallbackResilienceStrategy.cs

@@ -10,15 +10,14 @@ internal sealed class FallbackResilienceStrategy<T> : OutcomeResilienceStrategy<
     private readonly Func<OutcomeArguments<T, OnFallbackArguments>, ValueTask>? _onFallback;
     private readonly ResilienceStrategyTelemetry _telemetry;
 
-    public FallbackResilienceStrategy(FallbackHandler<T> handler, Func<OutcomeArguments<T, OnFallbackArguments>, ValueTask>? onFallback, ResilienceStrategyTelemetry telemetry, bool isGeneric)
-        : base(isGeneric)
+    public FallbackResilienceStrategy(FallbackHandler<T> handler, Func<OutcomeArguments<T, OnFallbackArguments>, ValueTask>? onFallback, ResilienceStrategyTelemetry telemetry)
     {
         _handler = handler;
         _onFallback = onFallback;
         _telemetry = telemetry;
     }
 
-    protected override async ValueTask<Outcome<T>> ExecuteCallbackAsync<TState>(Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback, ResilienceContext context, TState state)
+    protected override async ValueTask<Outcome<T>> ExecuteCore<TState>(Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback, ResilienceContext context, TState state)
     {
         var outcome = await ExecuteCallbackSafeAsync(callback, context, state).ConfigureAwait(context.ContinueOnCapturedContext);
         var handleFallbackArgs = new OutcomeArguments<T, FallbackPredicateArguments>(context, outcome, default);

src/Polly.Core/Fallback/FallbackResilienceStrategyBuilderExtensions.cs

@@ -62,8 +62,7 @@ internal static ResilienceStrategyBuilder AddFallback(this ResilienceStrategyBui
             return new FallbackResilienceStrategy<TResult>(
                 handler,
                 options.OnFallback,
-                context.Telemetry,
-                context.IsGenericBuilder);
+                context.Telemetry);
         },
         options);
     }

src/Polly.Core/Hedging/HedgingResilienceStrategy.cs

@@ -17,9 +17,7 @@ public HedgingResilienceStrategy(
         Func<OutcomeArguments<T, OnHedgingArguments>, ValueTask>? onHedging,
         Func<HedgingDelayArguments, ValueTask<TimeSpan>>? hedgingDelayGenerator,
         TimeProvider timeProvider,
-        ResilienceStrategyTelemetry telemetry,
-        bool isGeneric)
-        : base(isGeneric)
+        ResilienceStrategyTelemetry telemetry)
     {
         HedgingDelay = hedgingDelay;
         MaxHedgedAttempts = maxHedgedAttempts;
@@ -43,7 +41,7 @@ public HedgingResilienceStrategy(
     public Func<OutcomeArguments<T, OnHedgingArguments>, ValueTask>? OnHedging { get; }
 
     [ExcludeFromCodeCoverage] // coverlet issue
-    protected override async ValueTask<Outcome<T>> ExecuteCallbackAsync<TState>(
+    protected override async ValueTask<Outcome<T>> ExecuteCore<TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback,
         ResilienceContext context,
         TState state)

src/Polly.Core/Hedging/HedgingResilienceStrategyBuilderExtensions.cs

@@ -67,8 +67,7 @@ internal static ResilienceStrategyBuilder AddHedging(this ResilienceStrategyBuil
                 options.OnHedging,
                 options.HedgingDelayGenerator,
                 context.TimeProvider,
-                context.Telemetry,
-                context.IsGenericBuilder);
+                context.Telemetry);
         },
         options);
     }

src/Polly.Core/Retry/RetryResilienceStrategy.cs

@@ -11,11 +11,9 @@ internal sealed class RetryResilienceStrategy<T> : OutcomeResilienceStrategy<T>
 
     public RetryResilienceStrategy(
         RetryStrategyOptions<T> options,
-        bool isGeneric,
         TimeProvider timeProvider,
         ResilienceStrategyTelemetry telemetry,
         Func<double> randomizer)
-        : base(isGeneric)
     {
         ShouldHandle = options.ShouldHandle;
         BaseDelay = options.BaseDelay;
@@ -41,7 +39,7 @@ public RetryResilienceStrategy(
 
     public Func<OutcomeArguments<T, OnRetryArguments>, ValueTask>? OnRetry { get; }
 
-    protected override async ValueTask<Outcome<T>> ExecuteCallbackAsync<TState>(Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback, ResilienceContext context, TState state)
+    protected override async ValueTask<Outcome<T>> ExecuteCore<TState>(Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback, ResilienceContext context, TState state)
     {
         double retryState = 0;
 

src/Polly.Core/Retry/RetryResilienceStrategyBuilderExtensions.cs

@@ -55,7 +55,6 @@ public static ResilienceStrategyBuilder<TResult> AddRetry<TResult>(this Resilien
         builder.AddStrategy(context =>
             new RetryResilienceStrategy<TResult>(
                 options,
-                context.IsGenericBuilder,
                 context.TimeProvider,
                 context.Telemetry,
                 context.Randomizer),

src/Polly.Core/Utils/OutcomeResilienceStrategy.cs

@@ -10,71 +10,41 @@
 /// </remarks>
 internal abstract class OutcomeResilienceStrategy<T> : ResilienceStrategy
 {
-    private readonly bool _isGeneric;
-
-    protected OutcomeResilienceStrategy(bool isGeneric)
+    protected OutcomeResilienceStrategy()
     {
-        if (!isGeneric && typeof(T) != typeof(object))
-        {
-            throw new NotSupportedException("For non-generic strategies the generic parameter should be of type 'object'.");
-        }
-
-        _isGeneric = isGeneric;
     }
 
     protected internal sealed override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state)
     {
-        if (_isGeneric)
+        // Check if we can cast directly, thus saving some cycles and improving the performance
+        if (context.ResultType == typeof(T))
         {
-            if (typeof(TResult) != typeof(T))
-            {
-                return callback(context, state);
-            }
-
             // cast is safe here, because TResult and T are the same type
             var callbackCasted = (Func<ResilienceContext, TState, ValueTask<Outcome<T>>>)(object)callback;
-            var valueTask = ExecuteCallbackAsync(callbackCasted, context, state);
+            var valueTask = ExecuteCore(callbackCasted, context, state);
 
-            return ConvertValueTask<TResult>(valueTask, context);
+            return TaskHelper.ConvertValueTask<T, TResult>(valueTask, context);
         }
         else
         {
-            var valueTask = ExecuteCallbackAsync(
+            var valueTask = ExecuteCore(
                 static async (context, state) =>
                 {
                     var outcome = await state.callback(context, state.state).ConfigureAwait(context.ContinueOnCapturedContext);
-
-                    // cast the outcome to "object" based on (T)
                     return outcome.AsOutcome<T>();
                 },
                 context,
                 (callback, state));
 
-            return ConvertValueTask<TResult>(valueTask, context);
+            return TaskHelper.ConvertValueTask<T, TResult>(valueTask, context);
         }
     }
 
-    protected abstract ValueTask<Outcome<T>> ExecuteCallbackAsync<TState>(
+    protected abstract ValueTask<Outcome<T>> ExecuteCore<TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback,
         ResilienceContext context,
         TState state);
-
-    private static ValueTask<Outcome<TResult>> ConvertValueTask<TResult>(ValueTask<Outcome<T>> valueTask, ResilienceContext resilienceContext)
-    {
-        if (valueTask.IsCompletedSuccessfully)
-        {
-            return new ValueTask<Outcome<TResult>>(valueTask.Result.AsOutcome<TResult>());
-        }
-
-        return ConvertValueTaskAsync(valueTask, resilienceContext);
-
-        static async ValueTask<Outcome<TResult>> ConvertValueTaskAsync(ValueTask<Outcome<T>> valueTask, ResilienceContext resilienceContext)
-        {
-            var outcome = await valueTask.ConfigureAwait(resilienceContext.ContinueOnCapturedContext);
-            return outcome.AsOutcome<TResult>();
-        }
-    }
 }

src/Polly.Core/Utils/TaskHelper.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+
+namespace Polly.Utils;
+
+internal static class TaskHelper
+{
+    public static ValueTask<Outcome<TTo>> ConvertValueTask<TFrom, TTo>(ValueTask<Outcome<TFrom>> valueTask, ResilienceContext resilienceContext)
+    {
+        if (valueTask.IsCompletedSuccessfully)
+        {
+            return new ValueTask<Outcome<TTo>>(valueTask.Result.AsOutcome<TTo>());
+        }
+
+        return ConvertValueTaskAsync(valueTask, resilienceContext);
+
+        static async ValueTask<Outcome<TTo>> ConvertValueTaskAsync(ValueTask<Outcome<TFrom>> valueTask, ResilienceContext resilienceContext)
+        {
+            var outcome = await valueTask.ConfigureAwait(resilienceContext.ContinueOnCapturedContext);
+            return outcome.AsOutcome<TTo>();
+        }
+    }
+}