Use StrategyHelper for safe executions and drop redundant methods

src/Polly.Core/CircuitBreaker/CircuitBreakerResilienceStrategy.cs

@@ -1,3 +1,5 @@
+using Polly.Utils;
+
 namespace Polly.CircuitBreaker;
 
 internal sealed class CircuitBreakerResilienceStrategy<T> : ReactiveResilienceStrategy<T>
@@ -28,7 +30,7 @@ protected internal override async ValueTask<Outcome<T>> ExecuteCore<TState>(Func
             return outcome;
         }
 
-        outcome = await ExecuteCallbackSafeAsync(callback, context, state).ConfigureAwait(context.ContinueOnCapturedContext);
+        outcome = await StrategyHelper.ExecuteCallbackSafeAsync(callback, context, state).ConfigureAwait(context.ContinueOnCapturedContext);
 
         var args = new OutcomeArguments<T, CircuitBreakerPredicateArguments>(context, outcome, default);
         if (await _handler(args).ConfigureAwait(context.ContinueOnCapturedContext))

src/Polly.Core/Fallback/FallbackResilienceStrategy.cs

@@ -19,7 +19,7 @@ public FallbackResilienceStrategy(FallbackHandler<T> handler, Func<OutcomeArgume
 
     protected internal 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 outcome = await StrategyHelper.ExecuteCallbackSafeAsync(callback, context, state).ConfigureAwait(context.ContinueOnCapturedContext);
         var handleFallbackArgs = new OutcomeArguments<T, FallbackPredicateArguments>(context, outcome, default);
         if (!await _handler.ShouldHandle(handleFallbackArgs).ConfigureAwait(context.ContinueOnCapturedContext))
         {

src/Polly.Core/ReactiveResilienceStrategy.cs

@@ -37,9 +37,4 @@ protected internal abstract ValueTask<Outcome<TResult>> ExecuteCore<TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state);
-
-    internal static ValueTask<Outcome<T>> ExecuteCallbackSafeAsync<T, TState>(
-        Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback,
-        ResilienceContext context,
-        TState state) => StrategyHelper.ExecuteCallbackSafeAsync(callback, context, state);
 }

src/Polly.Core/ResilienceStrategy.cs

@@ -59,9 +59,4 @@ private Outcome<TResult> ExecuteCoreSync<TResult, TState>(
             context,
             (callback, state)).GetResult();
     }
-
-    internal static ValueTask<Outcome<TResult>> ExecuteCallbackSafeAsync<TResult, TState>(
-        Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
-        ResilienceContext context,
-        TState state) => StrategyHelper.ExecuteCallbackSafeAsync(callback, context, state);
 }

src/Polly.Core/Retry/RetryResilienceStrategy.cs

@@ -51,7 +51,7 @@ protected internal override async ValueTask<Outcome<T>> ExecuteCore<TState>(Func
         while (true)
         {
             var startTimestamp = _timeProvider.GetTimestamp();
-            var outcome = await ExecuteCallbackSafeAsync(callback, context, state).ConfigureAwait(context.ContinueOnCapturedContext);
+            var outcome = await StrategyHelper.ExecuteCallbackSafeAsync(callback, context, state).ConfigureAwait(context.ContinueOnCapturedContext);
             var shouldRetryArgs = new OutcomeArguments<T, RetryPredicateArguments>(context, outcome, new RetryPredicateArguments(attempt));
             var handle = await ShouldHandle(shouldRetryArgs).ConfigureAwait(context.ContinueOnCapturedContext);
             var executionTime = _timeProvider.GetElapsedTime(startTimestamp);

src/Polly.Core/Timeout/TimeoutResilienceStrategy.cs

@@ -45,7 +45,7 @@ protected internal override async ValueTask<Outcome<TResult>> ExecuteCore<TResul
 
         var registration = CreateRegistration(cancellationSource, previousToken);
 
-        var outcome = await ExecuteCallbackSafeAsync(callback, context, state).ConfigureAwait(context.ContinueOnCapturedContext);
+        var outcome = await StrategyHelper.ExecuteCallbackSafeAsync(callback, context, state).ConfigureAwait(context.ContinueOnCapturedContext);
         var isCancellationRequested = cancellationSource.IsCancellationRequested;
 
         // execution is finished, clean up

test/Polly.Core.Tests/ResilienceStrategyTests.cs

@@ -6,30 +6,6 @@ public partial class ResilienceStrategyTests
 {
     public static readonly CancellationToken CancellationToken = new CancellationTokenSource().Token;
 
-    [InlineData(true)]
-    [InlineData(false)]
-    [Theory]
-    public async Task ExecuteCallbackSafeAsync_CallbackThrows_EnsureExceptionWrapped(bool isAsync)
-    {
-        await TestUtilities.AssertWithTimeoutAsync(async () =>
-        {
-            var outcome = await ResilienceStrategy.ExecuteCallbackSafeAsync<string, string>(
-            async (_, _) =>
-            {
-                if (isAsync)
-                {
-                    await Task.Delay(15);
-                }
-
-                throw new InvalidOperationException();
-            },
-            ResilienceContextPool.Shared.Get(),
-            "dummy");
-
-            outcome.Exception.Should().BeOfType<InvalidOperationException>();
-        });
-    }
-
     [Fact]
     public void DebuggerProxy_Ok()
     {

test/Polly.Core.Tests/Utils/StrategyHelperTests.cs

@@ -0,0 +1,30 @@
+using Polly.Utils;
+
+namespace Polly.Core.Tests.Utils;
+
+public class StrategyHelperTests
+{
+    [InlineData(true)]
+    [InlineData(false)]
+    [Theory]
+    public async Task ExecuteCallbackSafeAsync_CallbackThrows_EnsureExceptionWrapped(bool isAsync)
+    {
+        await TestUtilities.AssertWithTimeoutAsync(async () =>
+        {
+            var outcome = await StrategyHelper.ExecuteCallbackSafeAsync<string, string>(
+                async (_, _) =>
+                {
+                    if (isAsync)
+                    {
+                        await Task.Delay(15);
+                    }
+
+                    throw new InvalidOperationException();
+                },
+                ResilienceContextPool.Shared.Get(),
+                "dummy");
+
+            outcome.Exception.Should().BeOfType<InvalidOperationException>();
+        });
+    }
+}