Rename ExecuteCoreAsync to ExecuteCore (#1424)

martintmk · web-flow · commit b9ce23203659 · 2023-07-24T06:55:10.000Z
diff --git a/bench/Polly.Core.Benchmarks/TelemetryBenchmark.cs b/bench/Polly.Core.Benchmarks/TelemetryBenchmark.cs
@@ -73,7 +73,7 @@ private class TelemetryEventStrategy : ResilienceStrategy
 
         public TelemetryEventStrategy(ResilienceStrategyTelemetry telemetry) => _telemetry = telemetry;
 
-        protected override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+        protected override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
             ResilienceContext context,
             TState state)
diff --git a/bench/Polly.Core.Benchmarks/Utils/EmptyResilienceStrategy.cs b/bench/Polly.Core.Benchmarks/Utils/EmptyResilienceStrategy.cs
@@ -2,7 +2,7 @@ namespace Polly.Core.Benchmarks.Utils;
 
 internal class EmptyResilienceStrategy : ResilienceStrategy
 {
-    protected override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state)
diff --git a/bench/Polly.Core.Benchmarks/Utils/Helper.CircuitBreaker.cs b/bench/Polly.Core.Benchmarks/Utils/Helper.CircuitBreaker.cs
@@ -66,7 +66,7 @@ public static object CreateCircuitBreaker(PollyVersion technology)
 
     private class OutcomeHandlingStrategy : ResilienceStrategy
     {
-        protected override async ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+        protected override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
             ResilienceContext context,
             TState state)
diff --git a/src/Polly.Core/NullResilienceStrategy.cs b/src/Polly.Core/NullResilienceStrategy.cs
@@ -15,7 +15,7 @@ private NullResilienceStrategy()
     }
 
     /// <inheritdoc/>
-    protected internal override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected internal override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state)
diff --git a/src/Polly.Core/PublicAPI.Unshipped.txt b/src/Polly.Core/PublicAPI.Unshipped.txt
@@ -3,7 +3,7 @@ abstract Polly.Registry.ResilienceStrategyProvider<TKey>.TryGetStrategy(TKey key
 abstract Polly.Registry.ResilienceStrategyProvider<TKey>.TryGetStrategy<TResult>(TKey key, out Polly.ResilienceStrategy<TResult>? strategy) -> bool
 abstract Polly.ResilienceContextPool.Get(string? operationKey, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Polly.ResilienceContext!
 abstract Polly.ResilienceContextPool.Return(Polly.ResilienceContext! context) -> void
-abstract Polly.ResilienceStrategy.ExecuteCoreAsync<TResult, TState>(System.Func<Polly.ResilienceContext!, TState, System.Threading.Tasks.ValueTask<Polly.Outcome<TResult>>>! callback, Polly.ResilienceContext! context, TState state) -> System.Threading.Tasks.ValueTask<Polly.Outcome<TResult>>
+abstract Polly.ResilienceStrategy.ExecuteCore<TResult, TState>(System.Func<Polly.ResilienceContext!, TState, System.Threading.Tasks.ValueTask<Polly.Outcome<TResult>>>! callback, Polly.ResilienceContext! context, TState state) -> System.Threading.Tasks.ValueTask<Polly.Outcome<TResult>>
 override Polly.Outcome<TResult>.ToString() -> string!
 override Polly.Registry.ResilienceStrategyRegistry<TKey>.TryGetStrategy(TKey key, out Polly.ResilienceStrategy? strategy) -> bool
 override Polly.Registry.ResilienceStrategyRegistry<TKey>.TryGetStrategy<TResult>(TKey key, out Polly.ResilienceStrategy<TResult>? strategy) -> bool
diff --git a/src/Polly.Core/README.md b/src/Polly.Core/README.md
@@ -73,7 +73,7 @@ public void Execute(Action execute)
 
     try
     {
-        strategy.ExecuteCoreAsync(static (context, state) =>
+        strategy.ExecuteAsync(static (context, state) =>
         {
             state();
             return new ValueTask<Outcome<VoidResult>>(new(VoidResult.Instance));
@@ -108,7 +108,7 @@ internal class DelayStrategy : ResilienceStrategy
         _timeProvider = timeProvider;
     }
 
-    protected override async ValueTask<T> ExecuteCoreAsync<T, TState>(
+    protected override async ValueTask<T> ExecuteCore<T, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback, 
         ResilienceContext context, 
         TState state)
diff --git a/src/Polly.Core/ResilienceStrategy.Async.ValueTask.cs b/src/Polly.Core/ResilienceStrategy.Async.ValueTask.cs
@@ -24,7 +24,7 @@ public async ValueTask ExecuteAsync<TState>(
 
         InitializeAsyncContext(context);
 
-        var outcome = await ExecuteCoreAsync(
+        var outcome = await ExecuteCore(
             static async (context, state) =>
             {
                 try
@@ -59,7 +59,7 @@ public async ValueTask ExecuteAsync(
 
         InitializeAsyncContext(context);
 
-        var outcome = await ExecuteCoreAsync(
+        var outcome = await ExecuteCore(
             static async (context, state) =>
             {
                 try
@@ -98,7 +98,7 @@ public async ValueTask ExecuteAsync<TState>(
 
         try
         {
-            var outcome = await ExecuteCoreAsync(
+            var outcome = await ExecuteCore(
                 static async (context, state) =>
                 {
                     try
@@ -139,7 +139,7 @@ public async ValueTask ExecuteAsync(
 
         try
         {
-            var outcome = await ExecuteCoreAsync(
+            var outcome = await ExecuteCore(
                 static async (context, state) =>
                 {
                     try
diff --git a/src/Polly.Core/ResilienceStrategy.Async.ValueTaskT.cs b/src/Polly.Core/ResilienceStrategy.Async.ValueTaskT.cs
@@ -29,7 +29,7 @@ public ValueTask<Outcome<TResult>> ExecuteOutcomeAsync<TResult, TState>(
 
         InitializeAsyncContext<TResult>(context);
 
-        return ExecuteCoreAsync(callback, context, state);
+        return ExecuteCore(callback, context, state);
     }
 
     /// <summary>
@@ -52,7 +52,7 @@ public async ValueTask<TResult> ExecuteAsync<TResult, TState>(
 
         InitializeAsyncContext<TResult>(context);
 
-        var outcome = await ExecuteCoreAsync(
+        var outcome = await ExecuteCore(
             static async (context, state) =>
             {
                 try
@@ -87,7 +87,7 @@ public async ValueTask<TResult> ExecuteAsync<TResult>(
 
         InitializeAsyncContext<TResult>(context);
 
-        var outcome = await ExecuteCoreAsync(
+        var outcome = await ExecuteCore(
             static async (context, state) =>
             {
                 try
@@ -126,7 +126,7 @@ public async ValueTask<TResult> ExecuteAsync<TResult, TState>(
 
         try
         {
-            var outcome = await ExecuteCoreAsync(
+            var outcome = await ExecuteCore(
                 static async (context, state) =>
                 {
                     try
@@ -167,7 +167,7 @@ public async ValueTask<TResult> ExecuteAsync<TResult>(
 
         try
         {
-            var outcome = await ExecuteCoreAsync(
+            var outcome = await ExecuteCore(
                 static async (context, state) =>
                 {
                     try
diff --git a/src/Polly.Core/ResilienceStrategy.cs b/src/Polly.Core/ResilienceStrategy.cs
@@ -16,25 +16,29 @@ public abstract partial class ResilienceStrategy
     internal ResilienceStrategyOptions? Options { get; set; }
 
     /// <summary>
-    /// Executes the specified callback.
+    /// An implementation of resilience strategy that executes the specified <paramref name="callback"/>.
     /// </summary>
     /// <typeparam name="TResult">The type of result returned by the callback.</typeparam>
     /// <typeparam name="TState">The type of state associated with the callback.</typeparam>
     /// <param name="callback">The user-provided callback.</param>
     /// <param name="context">The context associated with the callback.</param>
     /// <param name="state">The state associated with the callback.</param>
-    /// <returns>An instance of <see cref="ValueTask"/> that represents an asynchronous callback.</returns>
+    /// <returns>
+    /// An instance of pending <see cref="ValueTask"/> for asynchronous executions or completed <see cref="ValueTask"/> task for synchronous exexutions.
+    /// </returns>
     /// <remarks>
-    /// This method is called by various methods exposed on <see cref="ResilienceStrategy"/>. These methods make sure that
-    /// <paramref name="context"/> is properly initialized with details about the execution mode.
+    /// <strong>This method is called for both synchronous and asynchronous execution flows.</strong>
     /// <para>
-    /// The provided callback never throws an exception. Instead, the exception is captured and converted to an <see cref="Outcome{TResult}"/>.
+    /// You can use <see cref="ResilienceContext.IsSynchronous"/> to dermine wheether the <paramref name="callback"/> is synchronous or asynchronous one.
+    /// This is useful when the custom strategy behaves differently in each execution flow. In general, for most strategies, the implementation
+    /// is the same for both execution flows.
     /// </para>
     /// <para>
-    /// Do not throw exceptions from your strategy implementation. Instead, return an exception instance as <see cref="Outcome{TResult}"/>.
+    /// The provided callback never throws an exception. Instead, the exception is captured and converted to an <see cref="Outcome{TResult}"/>.
+    /// Similarly, do not throw exceptions from your strategy implementation. Instead, return an exception instance as <see cref="Outcome{TResult}"/>.
     /// </para>
     /// </remarks>
-    protected internal abstract ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected internal abstract ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state);
@@ -44,7 +48,7 @@ private Outcome<TResult> ExecuteCoreSync<TResult, TState>(
         ResilienceContext context,
         TState state)
     {
-        return ExecuteCoreAsync(
+        return ExecuteCore(
             static (context, state) =>
             {
                 var result = state.callback(context, state.state);
diff --git a/src/Polly.Core/Timeout/TimeoutResilienceStrategy.cs b/src/Polly.Core/Timeout/TimeoutResilienceStrategy.cs
@@ -22,7 +22,7 @@ public TimeoutResilienceStrategy(TimeoutStrategyOptions options, TimeProvider ti
 
     public Func<OnTimeoutArguments, ValueTask>? OnTimeout { get; }
 
-    protected internal override async ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected internal override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state)
diff --git a/src/Polly.Core/Utils/OutcomeResilienceStrategy.cs b/src/Polly.Core/Utils/OutcomeResilienceStrategy.cs
@@ -22,7 +22,7 @@ protected OutcomeResilienceStrategy(bool isGeneric)
         _isGeneric = isGeneric;
     }
 
-    protected internal sealed override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected internal sealed override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state)
diff --git a/src/Polly.Core/Utils/ReloadableResilienceStrategy.cs b/src/Polly.Core/Utils/ReloadableResilienceStrategy.cs
@@ -30,12 +30,12 @@ public ReloadableResilienceStrategy(
 
     public ResilienceStrategy Strategy { get; private set; }
 
-    protected internal override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected internal override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state)
     {
-        return Strategy.ExecuteCoreAsync(callback, context, state);
+        return Strategy.ExecuteCore(callback, context, state);
     }
 
     private void RegisterOnReload(CancellationToken previousToken)
diff --git a/src/Polly.Core/Utils/ResilienceStrategyPipeline.cs b/src/Polly.Core/Utils/ResilienceStrategyPipeline.cs
@@ -57,7 +57,7 @@ private ResilienceStrategyPipeline(ResilienceStrategy pipeline, IReadOnlyList<Re
 
     public IReadOnlyList<ResilienceStrategy> Strategies { get; }
 
-    protected internal override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected internal override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context, TState state)
     {
@@ -66,7 +66,7 @@ protected internal override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult
             return Outcome.FromExceptionAsTask<TResult>(new OperationCanceledException(context.CancellationToken).TrySetStackTrace());
         }
 
-        return _pipeline.ExecuteCoreAsync(callback, context, state);
+        return _pipeline.ExecuteCore(callback, context, state);
     }
 
     /// <summary>
@@ -80,20 +80,20 @@ private sealed class DelegatingResilienceStrategy : ResilienceStrategy
 
         public ResilienceStrategy? Next { get; set; }
 
-        protected internal override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+        protected internal override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
             ResilienceContext context,
             TState state)
         {
-            return _strategy.ExecuteCoreAsync(
+            return _strategy.ExecuteCore(
                 static (context, state) =>
                 {
                     if (context.CancellationToken.IsCancellationRequested)
                     {
                         return Outcome.FromExceptionAsTask<TResult>(new OperationCanceledException(context.CancellationToken).TrySetStackTrace());
                     }
 
-                    return state.Next!.ExecuteCoreAsync(state.callback, context, state.state);
+                    return state.Next!.ExecuteCore(state.callback, context, state.state);
                 },
                 context,
                 (Next, callback, state));
diff --git a/src/Polly.Core/Utils/TimeProviderExtensions.cs b/src/Polly.Core/Utils/TimeProviderExtensions.cs
@@ -29,7 +29,7 @@ public static Task DelayAsync(this TimeProvider timeProvider, TimeSpan delay, Re
             // For synchronous scenarios we want to return a completed task. We avoid
             // the use of Thread.Sleep() here because it is not cancellable and to
             // simplify the code. Sync-over-async is not a concern here because it
-            // only applies in the case of a reilience event and not on the hot path.
+            // only applies in the case of a resilience event and not on the hot path.
             timeProvider.Delay(delay, context.CancellationToken).GetAwaiter().GetResult();
 #pragma warning restore CA1849
 
diff --git a/src/Polly.Extensions/Telemetry/TelemetryResilienceStrategy.cs b/src/Polly.Extensions/Telemetry/TelemetryResilienceStrategy.cs
@@ -45,7 +45,7 @@ public TelemetryResilienceStrategy(
 
     public Histogram<double> ExecutionDuration { get; }
 
-    protected override async ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state)
diff --git a/src/Polly.RateLimiting/RateLimiterResilienceStrategy.cs b/src/Polly.RateLimiting/RateLimiterResilienceStrategy.cs
@@ -22,7 +22,7 @@ public RateLimiterResilienceStrategy(
 
     public Func<OnRateLimiterRejectedArguments, ValueTask>? OnLeaseRejected { get; }
 
-    protected override async ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state)
diff --git a/test/Polly.Core.Tests/ResilienceStrategyBuilderTests.cs b/test/Polly.Core.Tests/ResilienceStrategyBuilderTests.cs
@@ -409,7 +409,7 @@ private class Strategy : ResilienceStrategy
 
         public Action? After { get; set; }
 
-        protected internal override async ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+        protected internal override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
             ResilienceContext context,
             TState state)
@@ -432,7 +432,7 @@ private class ExecuteCallbackTwiceStrategy : ResilienceStrategy
 
         public Action? After { get; set; }
 
-        protected internal override async ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+        protected internal override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
             ResilienceContext context,
             TState state)
diff --git a/test/Polly.Core.Tests/Utils/ResilienceStrategyPipelineTests.cs b/test/Polly.Core.Tests/Utils/ResilienceStrategyPipelineTests.cs
@@ -48,7 +48,7 @@ public async Task CreatePipeline_EnsureExceptionsNotWrapped()
 
         var pipeline = ResilienceStrategyPipeline.CreatePipeline(strategies);
         await pipeline
-            .Invoking(p => p.ExecuteCoreAsync((_, _) => Outcome.FromResultAsTask(10), ResilienceContextPool.Shared.Get(), "state").AsTask())
+            .Invoking(p => p.ExecuteCore((_, _) => Outcome.FromResultAsTask(10), ResilienceContextPool.Shared.Get(), "state").AsTask())
             .Should()
             .ThrowAsync<NotSupportedException>();
     }
@@ -113,7 +113,7 @@ public async Task CreatePipeline_CancelledLater_EnsureNoExecution()
 
     private class Strategy : ResilienceStrategy
     {
-        protected internal override async ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+        protected internal override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
             ResilienceContext context,
             TState state)
diff --git a/test/Polly.Extensions.Tests/DependencyInjection/PollyServiceCollectionExtensionTests.cs b/test/Polly.Extensions.Tests/DependencyInjection/PollyServiceCollectionExtensionTests.cs
@@ -307,7 +307,7 @@ private ResilienceStrategyProvider<string> CreateProvider()
 
     private class TestStrategy : ResilienceStrategy
     {
-        protected override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+        protected override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
             ResilienceContext context,
             TState state) => new(Outcome.FromException<TResult>(new NotSupportedException()));
diff --git a/test/Polly.Extensions.Tests/Issues/IssuesTests.OnCircuitBreakWithServiceProvider_796.cs b/test/Polly.Extensions.Tests/Issues/IssuesTests.OnCircuitBreakWithServiceProvider_796.cs
@@ -60,7 +60,7 @@ private class ServiceProviderStrategy : ResilienceStrategy
 
         public ServiceProviderStrategy(IServiceProvider serviceProvider) => _serviceProvider = serviceProvider;
 
-        protected override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+        protected override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
             ResilienceContext context,
             TState state)
diff --git a/test/Polly.Extensions.Tests/ReloadableResilienceStrategyTests.cs b/test/Polly.Extensions.Tests/ReloadableResilienceStrategyTests.cs
@@ -60,7 +60,7 @@ public class ReloadableStrategy : ResilienceStrategy
 
         public string Tag { get; }
 
-        protected override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+        protected override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
             Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
             ResilienceContext context,
             TState state)
diff --git a/test/Polly.TestUtils/TestResilienceStrategy.cs b/test/Polly.TestUtils/TestResilienceStrategy.cs
@@ -8,7 +8,7 @@ public class TestResilienceStrategy : ResilienceStrategy
 
     public Func<ResilienceContext, object?, Task>? OnExecute { get; set; }
 
-    protected internal override async ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(
+    protected internal override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,
         ResilienceContext context,
         TState state)
diff --git a/test/Polly.Testing.Tests/ResilienceStrategyExtensionsTests.cs b/test/Polly.Testing.Tests/ResilienceStrategyExtensionsTests.cs
@@ -96,7 +96,7 @@ public void GetInnerStrategies_Reloadable_Ok()
 
     private sealed class CustomStrategy : ResilienceStrategy
     {
-        protected override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback, ResilienceContext context, TState state)
+        protected override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback, ResilienceContext context, TState state)
             => throw new NotSupportedException();
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ namespace Polly.Core.Benchmarks.Utils;`
`2`	`2`
`3`	`3`	`internal class EmptyResilienceStrategy : ResilienceStrategy`
`4`	`4`	`{`
`5`		`- protected override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(`
	`5`	`+ protected override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(`
`6`	`6`	`Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,`
`7`	`7`	`ResilienceContext context,`
`8`	`8`	`TState state)`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ public static object CreateCircuitBreaker(PollyVersion technology)`
`66`	`66`
`67`	`67`	`private class OutcomeHandlingStrategy : ResilienceStrategy`
`68`	`68`	`{`
`69`		`- protected override async ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(`
	`69`	`+ protected override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(`
`70`	`70`	`Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,`
`71`	`71`	`ResilienceContext context,`
`72`	`72`	`TState state)`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ private NullResilienceStrategy()`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`/// <inheritdoc/>`
`18`		`- protected internal override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(`
	`18`	`+ protected internal override ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(`
`19`	`19`	`Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,`
`20`	`20`	`ResilienceContext context,`
`21`	`21`	`TState state)`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public void Execute(Action execute)`
`73`	`73`
`74`	`74`	`try`
`75`	`75`	`{`
`76`		`- strategy.ExecuteCoreAsync(static (context, state) =>`
	`76`	`+ strategy.ExecuteAsync(static (context, state) =>`
`77`	`77`	`{`
`78`	`78`	`state();`
`79`	`79`	`return new ValueTask<Outcome<VoidResult>>(new(VoidResult.Instance));`
`@@ -108,7 +108,7 @@ internal class DelayStrategy : ResilienceStrategy`
`108`	`108`	`_timeProvider = timeProvider;`
`109`	`109`	`}`
`110`	`110`
`111`		`- protected override async ValueTask<T> ExecuteCoreAsync<T, TState>(`
	`111`	`+ protected override async ValueTask<T> ExecuteCore<T, TState>(`
`112`	`112`	`Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback,`
`113`	`113`	`ResilienceContext context,`
`114`	`114`	`TState state)`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public async ValueTask ExecuteAsync<TState>(`
`24`	`24`
`25`	`25`	`InitializeAsyncContext(context);`
`26`	`26`
`27`		`- var outcome = await ExecuteCoreAsync(`
	`27`	`+ var outcome = await ExecuteCore(`
`28`	`28`	`static async (context, state) =>`
`29`	`29`	`{`
`30`	`30`	`try`
`@@ -59,7 +59,7 @@ public async ValueTask ExecuteAsync(`
`59`	`59`
`60`	`60`	`InitializeAsyncContext(context);`
`61`	`61`
`62`		`- var outcome = await ExecuteCoreAsync(`
	`62`	`+ var outcome = await ExecuteCore(`
`63`	`63`	`static async (context, state) =>`
`64`	`64`	`{`
`65`	`65`	`try`
`@@ -98,7 +98,7 @@ public async ValueTask ExecuteAsync<TState>(`
`98`	`98`
`99`	`99`	`try`
`100`	`100`	`{`
`101`		`- var outcome = await ExecuteCoreAsync(`
	`101`	`+ var outcome = await ExecuteCore(`
`102`	`102`	`static async (context, state) =>`
`103`	`103`	`{`
`104`	`104`	`try`
`@@ -139,7 +139,7 @@ public async ValueTask ExecuteAsync(`
`139`	`139`
`140`	`140`	`try`
`141`	`141`	`{`
`142`		`- var outcome = await ExecuteCoreAsync(`
	`142`	`+ var outcome = await ExecuteCore(`
`143`	`143`	`static async (context, state) =>`
`144`	`144`	`{`
`145`	`145`	`try`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public ValueTask<Outcome<TResult>> ExecuteOutcomeAsync<TResult, TState>(`
`29`	`29`
`30`	`30`	`InitializeAsyncContext<TResult>(context);`
`31`	`31`
`32`		`- return ExecuteCoreAsync(callback, context, state);`
	`32`	`+ return ExecuteCore(callback, context, state);`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`/// <summary>`
`@@ -52,7 +52,7 @@ public async ValueTask<TResult> ExecuteAsync<TResult, TState>(`
`52`	`52`
`53`	`53`	`InitializeAsyncContext<TResult>(context);`
`54`	`54`
`55`		`- var outcome = await ExecuteCoreAsync(`
	`55`	`+ var outcome = await ExecuteCore(`
`56`	`56`	`static async (context, state) =>`
`57`	`57`	`{`
`58`	`58`	`try`
`@@ -87,7 +87,7 @@ public async ValueTask<TResult> ExecuteAsync<TResult>(`
`87`	`87`
`88`	`88`	`InitializeAsyncContext<TResult>(context);`
`89`	`89`
`90`		`- var outcome = await ExecuteCoreAsync(`
	`90`	`+ var outcome = await ExecuteCore(`
`91`	`91`	`static async (context, state) =>`
`92`	`92`	`{`
`93`	`93`	`try`
`@@ -126,7 +126,7 @@ public async ValueTask<TResult> ExecuteAsync<TResult, TState>(`
`126`	`126`
`127`	`127`	`try`
`128`	`128`	`{`
`129`		`- var outcome = await ExecuteCoreAsync(`
	`129`	`+ var outcome = await ExecuteCore(`
`130`	`130`	`static async (context, state) =>`
`131`	`131`	`{`
`132`	`132`	`try`
`@@ -167,7 +167,7 @@ public async ValueTask<TResult> ExecuteAsync<TResult>(`
`167`	`167`
`168`	`168`	`try`
`169`	`169`	`{`
`170`		`- var outcome = await ExecuteCoreAsync(`
	`170`	`+ var outcome = await ExecuteCore(`
`171`	`171`	`static async (context, state) =>`
`172`	`172`	`{`
`173`	`173`	`try`