diff --git a/src/Polly/AsyncPolicy.ExecuteOverloads.cs b/src/Polly/AsyncPolicy.ExecuteOverloads.cs
index 232ba2a3a9a..86b7f683f8f 100644
--- a/src/Polly/AsyncPolicy.ExecuteOverloads.cs
+++ b/src/Polly/AsyncPolicy.ExecuteOverloads.cs
@@ -100,23 +100,14 @@ public Task ExecuteAsync(Func<Context, CancellationToken, Task> action, IDiction
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     /// <returns>A <see cref="Task" /> which completes when <see cref="AsyncPolicy"/> is registered.</returns>
     [DebuggerStepThrough]
-    public async Task ExecuteAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
+    public Task ExecuteAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
     {
         if (context == null)
         {
             throw new ArgumentNullException(nameof(context));
         }
 
-        SetPolicyContext(context, out string priorPolicyWrapKey, out string priorPolicyKey);
-
-        try
-        {
-            await ImplementationAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext);
-        }
-        finally
-        {
-            PolicyBase.RestorePolicyContext(context, priorPolicyWrapKey, priorPolicyKey);
-        }
+        return ExecuteInternalAsync(action, context, continueOnCapturedContext, cancellationToken);
     }
 
     #region Overloads method-generic in TResult
@@ -226,23 +217,14 @@ public Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task
     /// <returns>The value returned by the action.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     [DebuggerStepThrough]
-    public async Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
+    public Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
     {
         if (context == null)
         {
             throw new ArgumentNullException(nameof(context));
         }
 
-        SetPolicyContext(context, out string priorPolicyWrapKey, out string priorPolicyKey);
-
-        try
-        {
-            return await ImplementationAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext);
-        }
-        finally
-        {
-            PolicyBase.RestorePolicyContext(context, priorPolicyWrapKey, priorPolicyKey);
-        }
+        return ExecuteInternalAsync(action, context, continueOnCapturedContext, cancellationToken);
     }
 
     #endregion
@@ -349,22 +331,14 @@ public Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     /// <returns>The captured result.</returns>
     [DebuggerStepThrough]
-    public async Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
+    public Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
     {
         if (context == null)
         {
             throw new ArgumentNullException(nameof(context));
         }
 
-        try
-        {
-            await ExecuteAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext);
-            return PolicyResult.Successful(context);
-        }
-        catch (Exception exception)
-        {
-            return PolicyResult.Failure(exception, GetExceptionType(ExceptionPredicates, exception), context);
-        }
+        return ExecuteAndCaptureInternalAsync(action, context, continueOnCapturedContext, cancellationToken);
     }
 
     #region Overloads method-generic in TResult
@@ -476,25 +450,88 @@ public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context,
     /// <returns>The captured result.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     [DebuggerStepThrough]
-    public async Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
+    public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(
+        Func<Context, CancellationToken, Task<TResult>> action,
+        Context context,
+        CancellationToken cancellationToken,
+        bool continueOnCapturedContext)
     {
         if (context == null)
         {
             throw new ArgumentNullException(nameof(context));
         }
 
+        return ExecuteAndCaptureInternalAsync(action, context, continueOnCapturedContext, cancellationToken);
+    }
+
+    #endregion
+
+    #endregion
+
+    private async Task ExecuteInternalAsync(Func<Context, CancellationToken, Task> action, Context context, bool continueOnCapturedContext, CancellationToken cancellationToken)
+    {
+        SetPolicyContext(context, out string priorPolicyWrapKey, out string priorPolicyKey);
+
+        try
+        {
+            await ImplementationAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext);
+        }
+        finally
+        {
+            PolicyBase.RestorePolicyContext(context, priorPolicyWrapKey, priorPolicyKey);
+        }
+    }
+
+    private async Task<TResult> ExecuteInternalAsync<TResult>(
+        Func<Context, CancellationToken, Task<TResult>> action,
+        Context context,
+        bool continueOnCapturedContext,
+        CancellationToken cancellationToken)
+    {
+        SetPolicyContext(context, out string priorPolicyWrapKey, out string priorPolicyKey);
+
+        try
+        {
+            return await ImplementationAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext);
+        }
+        finally
+        {
+            PolicyBase.RestorePolicyContext(context, priorPolicyWrapKey, priorPolicyKey);
+        }
+    }
+
+    private async Task<PolicyResult> ExecuteAndCaptureInternalAsync(
+        Func<Context, CancellationToken, Task> action,
+        Context context,
+        bool continueOnCapturedContext,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await ExecuteAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext);
+            return PolicyResult.Successful(context);
+        }
+        catch (Exception exception)
+        {
+            return PolicyResult.Failure(exception, GetExceptionType(ExceptionPredicates, exception), context);
+        }
+    }
+
+    private async Task<PolicyResult<TResult>> ExecuteAndCaptureInternalAsync<TResult>(
+        Func<Context, CancellationToken, Task<TResult>> action,
+        Context context,
+        bool continueOnCapturedContext,
+        CancellationToken cancellationToken)
+    {
         try
         {
             return PolicyResult<TResult>.Successful(
-                await ExecuteAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext), context);
+                await ExecuteAsync(action, context, cancellationToken, continueOnCapturedContext)
+                    .ConfigureAwait(continueOnCapturedContext), context);
         }
         catch (Exception exception)
         {
             return PolicyResult<TResult>.Failure(exception, GetExceptionType(ExceptionPredicates, exception), context);
         }
     }
-
-    #endregion
-
-    #endregion
 }
diff --git a/src/Polly/AsyncPolicy.TResult.ExecuteOverloads.cs b/src/Polly/AsyncPolicy.TResult.ExecuteOverloads.cs
index 8e704d5b2e5..549cf6fedf7 100644
--- a/src/Polly/AsyncPolicy.TResult.ExecuteOverloads.cs
+++ b/src/Polly/AsyncPolicy.TResult.ExecuteOverloads.cs
@@ -100,23 +100,14 @@ public Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>
     /// <returns>The value returned by the action.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     [DebuggerStepThrough]
-    public async Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
+    public Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
     {
         if (context == null)
         {
             throw new ArgumentNullException(nameof(context));
         }
 
-        SetPolicyContext(context, out string priorPolicyWrapKey, out string priorPolicyKey);
-
-        try
-        {
-            return await ImplementationAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext);
-        }
-        finally
-        {
-            PolicyBase.RestorePolicyContext(context, priorPolicyWrapKey, priorPolicyKey);
-        }
+        return ExecuteInternalAsync(action, context, continueOnCapturedContext, cancellationToken);
     }
 
     #endregion
@@ -221,13 +212,42 @@ public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, Cancella
     /// <returns>The captured result.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     [DebuggerStepThrough]
-    public async Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
+    public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
     {
         if (context == null)
         {
             throw new ArgumentNullException(nameof(context));
         }
 
+        return ExecuteAndCaptureInternalAsync(action, context, continueOnCapturedContext, cancellationToken);
+    }
+
+    #endregion
+
+    private async Task<TResult> ExecuteInternalAsync(
+        Func<Context, CancellationToken, Task<TResult>> action,
+        Context context,
+        bool continueOnCapturedContext,
+        CancellationToken cancellationToken)
+    {
+        SetPolicyContext(context, out string priorPolicyWrapKey, out string priorPolicyKey);
+
+        try
+        {
+            return await ImplementationAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext);
+        }
+        finally
+        {
+            PolicyBase.RestorePolicyContext(context, priorPolicyWrapKey, priorPolicyKey);
+        }
+    }
+
+    private async Task<PolicyResult<TResult>> ExecuteAndCaptureInternalAsync(
+        Func<Context, CancellationToken, Task<TResult>> action,
+        Context context,
+        bool continueOnCapturedContext,
+        CancellationToken cancellationToken)
+    {
         try
         {
             TResult result = await ExecuteAsync(action, context, cancellationToken, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext);
@@ -244,6 +264,4 @@ public async Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, Ca
             return PolicyResult<TResult>.Failure(exception, GetExceptionType(ExceptionPredicates, exception), context);
         }
     }
-
-    #endregion
 }
diff --git a/src/Polly/Polly.csproj b/src/Polly/Polly.csproj
index ec5f53f0507..724f7d26e46 100644
--- a/src/Polly/Polly.csproj
+++ b/src/Polly/Polly.csproj
@@ -8,7 +8,7 @@
     <MutationScore>70</MutationScore>
     <IncludePollyUsings>true</IncludePollyUsings>
     <NoWarn>$(NoWarn);CA1010;CA1031;CA1051;CA1062;CA1063;CA1064;CA1710;CA1716;CA1724;CA1805;CA1815;CA1816;CA2211</NoWarn>
-    <NoWarn>$(NoWarn);S2223;S3215;S4039;S4457</NoWarn>
+    <NoWarn>$(NoWarn);S2223;S3215;S4039</NoWarn>
     <!--Public API Analyzers: We do not need to fix these as it would break compatibility with released Polly versions-->
     <NoWarn>$(NoWarn);RS0037;</NoWarn>
   </PropertyGroup>