diff --git a/src/Polly/AsyncPolicy.GenericImplementation.cs b/src/Polly/AsyncPolicy.GenericImplementation.cs
index 809e7781c70..152e9900857 100644
--- a/src/Polly/AsyncPolicy.GenericImplementation.cs
+++ b/src/Polly/AsyncPolicy.GenericImplementation.cs
@@ -2,6 +2,7 @@
 
 public abstract partial class AsyncPolicy<TResult>
 {
+#pragma warning disable CA1068
     /// <summary>
     /// Defines the implementation of a policy for async executions returning <typeparamref name="TResult"/>.
     /// </summary>
@@ -15,4 +16,5 @@ protected abstract Task<TResult> ImplementationAsync(
         Context context,
         CancellationToken cancellationToken,
         bool continueOnCapturedContext);
+#pragma warning restore CA1068
 }
diff --git a/src/Polly/AsyncPolicy.NonGenericImplementation.cs b/src/Polly/AsyncPolicy.NonGenericImplementation.cs
index f54acfcdda3..5d04568d03f 100644
--- a/src/Polly/AsyncPolicy.NonGenericImplementation.cs
+++ b/src/Polly/AsyncPolicy.NonGenericImplementation.cs
@@ -2,6 +2,7 @@
 
 public abstract partial class AsyncPolicy
 {
+#pragma warning disable CA1068
     /// <summary>
     /// Defines the implementation of a policy for async executions with no return value.
     /// </summary>
@@ -16,11 +17,13 @@ protected virtual Task ImplementationAsync(
         CancellationToken cancellationToken,
         bool continueOnCapturedContext) =>
         ImplementationAsync<EmptyStruct>(async (ctx, token) =>
+#pragma warning restore CA1068
         {
             await action(ctx, token).ConfigureAwait(continueOnCapturedContext);
             return EmptyStruct.Instance;
         }, context, cancellationToken, continueOnCapturedContext);
 
+#pragma warning disable CA1068
     /// <summary>
     /// Defines the implementation of a policy for async executions returning <typeparamref name="TResult"/>.
     /// </summary>
@@ -35,4 +38,5 @@ protected abstract Task<TResult> ImplementationAsync<TResult>(
         Context context,
         CancellationToken cancellationToken,
         bool continueOnCapturedContext);
+#pragma warning restore CA1068
 }
diff --git a/src/Polly/Bulkhead/AsyncBulkheadEngine.cs b/src/Polly/Bulkhead/AsyncBulkheadEngine.cs
index 7640dc5216d..9c1a95f47a3 100644
--- a/src/Polly/Bulkhead/AsyncBulkheadEngine.cs
+++ b/src/Polly/Bulkhead/AsyncBulkheadEngine.cs
@@ -9,8 +9,8 @@ internal static async Task<TResult> ImplementationAsync<TResult>(
         Func<Context, Task> onBulkheadRejectedAsync,
         SemaphoreSlim maxParallelizationSemaphore,
         SemaphoreSlim maxQueuedActionsSemaphore,
-        CancellationToken cancellationToken,
-        bool continueOnCapturedContext)
+        bool continueOnCapturedContext,
+        CancellationToken cancellationToken)
     {
         if (!await maxQueuedActionsSemaphore.WaitAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(continueOnCapturedContext))
         {
diff --git a/src/Polly/Bulkhead/AsyncBulkheadPolicy.cs b/src/Polly/Bulkhead/AsyncBulkheadPolicy.cs
index f4f269580ff..426ad8d04ba 100644
--- a/src/Polly/Bulkhead/AsyncBulkheadPolicy.cs
+++ b/src/Polly/Bulkhead/AsyncBulkheadPolicy.cs
@@ -36,7 +36,7 @@ internal AsyncBulkheadPolicy(
     [DebuggerStepThrough]
     protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken,
         bool continueOnCapturedContext) =>
-        AsyncBulkheadEngine.ImplementationAsync(action, context, _onBulkheadRejectedAsync, _maxParallelizationSemaphore, _maxQueuedActionsSemaphore, cancellationToken, continueOnCapturedContext);
+        AsyncBulkheadEngine.ImplementationAsync(action, context, _onBulkheadRejectedAsync, _maxParallelizationSemaphore, _maxQueuedActionsSemaphore, continueOnCapturedContext, cancellationToken);
 
     /// <inheritdoc/>
     public void Dispose()
@@ -71,7 +71,7 @@ internal AsyncBulkheadPolicy(
     /// <inheritdoc/>
     [DebuggerStepThrough]
     protected override Task<TResult> ImplementationAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext) =>
-        AsyncBulkheadEngine.ImplementationAsync(action, context, _onBulkheadRejectedAsync, _maxParallelizationSemaphore, _maxQueuedActionsSemaphore, cancellationToken, continueOnCapturedContext);
+        AsyncBulkheadEngine.ImplementationAsync(action, context, _onBulkheadRejectedAsync, _maxParallelizationSemaphore, _maxQueuedActionsSemaphore, continueOnCapturedContext, cancellationToken);
 
     /// <summary>
     /// Gets the number of slots currently available for executing actions through the bulkhead.
diff --git a/src/Polly/Caching/AsyncCacheEngine.cs b/src/Polly/Caching/AsyncCacheEngine.cs
index 170b28c14f7..ccf9c2b195a 100644
--- a/src/Polly/Caching/AsyncCacheEngine.cs
+++ b/src/Polly/Caching/AsyncCacheEngine.cs
@@ -9,13 +9,13 @@ internal static async Task<TResult> ImplementationAsync<TResult>(
         Func<Context, string> cacheKeyStrategy,
         Func<Context, CancellationToken, Task<TResult>> action,
         Context context,
-        CancellationToken cancellationToken,
         bool continueOnCapturedContext,
         Action<Context, string> onCacheGet,
         Action<Context, string> onCacheMiss,
         Action<Context, string> onCachePut,
         Action<Context, string, Exception>? onCacheGetError,
-        Action<Context, string, Exception>? onCachePutError)
+        Action<Context, string, Exception>? onCachePutError,
+        CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
 
diff --git a/src/Polly/Caching/AsyncCachePolicy.cs b/src/Polly/Caching/AsyncCachePolicy.cs
index a4e0b925388..07f6f3ff8b9 100644
--- a/src/Polly/Caching/AsyncCachePolicy.cs
+++ b/src/Polly/Caching/AsyncCachePolicy.cs
@@ -54,13 +54,13 @@ protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, Canc
             _cacheKeyStrategy,
             action,
             context,
-            cancellationToken,
             continueOnCapturedContext,
             _onCacheGet,
             _onCacheMiss,
             _onCachePut,
             _onCacheGetError,
-            _onCachePutError);
+            _onCachePutError,
+            cancellationToken);
 }
 
 /// <summary>
@@ -111,12 +111,12 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT
             _cacheKeyStrategy,
             action,
             context,
-            cancellationToken,
             continueOnCapturedContext,
             _onCacheGet,
             _onCacheMiss,
             _onCachePut,
             _onCacheGetError,
-            _onCachePutError);
+            _onCachePutError,
+            cancellationToken);
 }
 
diff --git a/src/Polly/Caching/CacheEngine.cs b/src/Polly/Caching/CacheEngine.cs
index dca2d9d4af5..796b3e00ab4 100644
--- a/src/Polly/Caching/CacheEngine.cs
+++ b/src/Polly/Caching/CacheEngine.cs
@@ -9,12 +9,12 @@ internal static TResult Implementation<TResult>(
         Func<Context, string> cacheKeyStrategy,
         Func<Context, CancellationToken, TResult> action,
         Context context,
-        CancellationToken cancellationToken,
         Action<Context, string> onCacheGet,
         Action<Context, string> onCacheMiss,
         Action<Context, string> onCachePut,
         Action<Context, string, Exception>? onCacheGetError,
-        Action<Context, string, Exception>? onCachePutError)
+        Action<Context, string, Exception>? onCachePutError,
+        CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
 
diff --git a/src/Polly/Caching/CachePolicy.cs b/src/Polly/Caching/CachePolicy.cs
index efd576bc674..7d9df28e3a4 100644
--- a/src/Polly/Caching/CachePolicy.cs
+++ b/src/Polly/Caching/CachePolicy.cs
@@ -51,12 +51,12 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok
             _cacheKeyStrategy,
             action,
             context,
-            cancellationToken,
             _onCacheGet,
             _onCacheMiss,
             _onCachePut,
             _onCacheGetError,
-            _onCachePutError);
+            _onCachePutError,
+            cancellationToken);
 }
 
 /// <summary>
@@ -105,10 +105,10 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
             _cacheKeyStrategy,
             action,
             context,
-            cancellationToken,
             _onCacheGet,
             _onCacheMiss,
             _onCachePut,
             _onCacheGetError,
-            _onCachePutError);
+            _onCachePutError,
+            cancellationToken);
 }
diff --git a/src/Polly/Caching/IAsyncCacheProvider.cs b/src/Polly/Caching/IAsyncCacheProvider.cs
index e64d2bc09ad..401abccee71 100644
--- a/src/Polly/Caching/IAsyncCacheProvider.cs
+++ b/src/Polly/Caching/IAsyncCacheProvider.cs
@@ -7,6 +7,7 @@ namespace Polly.Caching;
 public interface IAsyncCacheProvider
 {
 #pragma warning disable SA1414
+#pragma warning disable CA1068
     /// <summary>
     /// Gets a value from the cache asynchronously.
     /// </summary>
@@ -18,8 +19,10 @@ public interface IAsyncCacheProvider
     /// the key was found in the cache, and whose second element is the value from the cache (null if not found).
     /// </returns>
     Task<(bool, object?)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext);
-#pragma warning restore  SA1414
+#pragma warning restore CA1068
+#pragma warning restore SA1414
 
+#pragma warning disable CA1068
     /// <summary>
     /// Puts the specified value in the cache asynchronously.
     /// </summary>
@@ -30,6 +33,7 @@ public interface IAsyncCacheProvider
     /// <param name="continueOnCapturedContext">Whether async calls should continue on a captured synchronization context.<para><remarks>Note: if the underlying cache's async API does not support controlling whether to continue on a captured context, async Policy executions with continueOnCapturedContext == true cannot be guaranteed to remain on the captured context.</remarks></para></param>
     /// <returns>A <see cref="Task" /> which completes when the value has been cached.</returns>
     Task PutAsync(string key, object? value, Ttl ttl, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 }
 
 /// <summary>
@@ -39,6 +43,7 @@ public interface IAsyncCacheProvider
 public interface IAsyncCacheProvider<TResult>
 {
 #pragma warning disable SA1414
+#pragma warning disable CA1068
     /// <summary>
     /// Gets a value from the cache asynchronously.
     /// </summary>
@@ -50,8 +55,10 @@ public interface IAsyncCacheProvider<TResult>
     /// the key was found in the cache, and whose second element is the value from the cache (default(TResult) if not found).
     /// </returns>
     Task<(bool, TResult?)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 #pragma warning restore SA1414
 
+#pragma warning disable CA1068
     /// <summary>
     /// Puts the specified value in the cache asynchronously.
     /// </summary>
@@ -62,4 +69,5 @@ public interface IAsyncCacheProvider<TResult>
     /// <param name="continueOnCapturedContext">Whether async calls should continue on a captured synchronization context.<para><remarks>Note: if the underlying cache's async API does not support controlling whether to continue on a captured context, async Policy executions with continueOnCapturedContext == true cannot be guaranteed to remain on the captured context.</remarks></para></param>
     /// <returns>A <see cref="Task" /> which completes when the value has been cached.</returns>
     Task PutAsync(string key, TResult? value, Ttl ttl, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 }
diff --git a/src/Polly/CircuitBreaker/AsyncCircuitBreakerEngine.cs b/src/Polly/CircuitBreaker/AsyncCircuitBreakerEngine.cs
index d0c2e479d81..89c6c31242c 100644
--- a/src/Polly/CircuitBreaker/AsyncCircuitBreakerEngine.cs
+++ b/src/Polly/CircuitBreaker/AsyncCircuitBreakerEngine.cs
@@ -5,11 +5,11 @@ internal class AsyncCircuitBreakerEngine
     internal static async Task<TResult> ImplementationAsync<TResult>(
         Func<Context, CancellationToken, Task<TResult>> action,
         Context context,
-        CancellationToken cancellationToken,
         bool continueOnCapturedContext,
         ExceptionPredicates shouldHandleExceptionPredicates,
         ResultPredicates<TResult> shouldHandleResultPredicates,
-        ICircuitController<TResult> breakerController)
+        ICircuitController<TResult> breakerController,
+        CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
 
diff --git a/src/Polly/CircuitBreaker/AsyncCircuitBreakerPolicy.cs b/src/Polly/CircuitBreaker/AsyncCircuitBreakerPolicy.cs
index cbe97e8da28..4832735a061 100644
--- a/src/Polly/CircuitBreaker/AsyncCircuitBreakerPolicy.cs
+++ b/src/Polly/CircuitBreaker/AsyncCircuitBreakerPolicy.cs
@@ -44,11 +44,11 @@ protected override async Task<TResult> ImplementationAsync<TResult>(Func<Context
         await AsyncCircuitBreakerEngine.ImplementationAsync<EmptyStruct>(
             async (ctx, ct) => { result = await action(ctx, ct).ConfigureAwait(continueOnCapturedContext); return EmptyStruct.Instance; },
             context,
-            cancellationToken,
             continueOnCapturedContext,
             ExceptionPredicates,
             ResultPredicates<EmptyStruct>.None,
-            BreakerController).ConfigureAwait(continueOnCapturedContext);
+            BreakerController,
+            cancellationToken).ConfigureAwait(continueOnCapturedContext);
         return result;
     }
 }
@@ -103,9 +103,9 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT
         AsyncCircuitBreakerEngine.ImplementationAsync(
             action,
             context,
-            cancellationToken,
             continueOnCapturedContext,
             ExceptionPredicates,
             ResultPredicates,
-            BreakerController);
+            BreakerController,
+            cancellationToken);
 }
diff --git a/src/Polly/CircuitBreaker/CircuitBreakerEngine.cs b/src/Polly/CircuitBreaker/CircuitBreakerEngine.cs
index 9f378d6d219..a51fd4b8803 100644
--- a/src/Polly/CircuitBreaker/CircuitBreakerEngine.cs
+++ b/src/Polly/CircuitBreaker/CircuitBreakerEngine.cs
@@ -7,10 +7,10 @@ internal class CircuitBreakerEngine
     internal static TResult Implementation<TResult>(
         Func<Context, CancellationToken, TResult> action,
         Context context,
-        CancellationToken cancellationToken,
         ExceptionPredicates shouldHandleExceptionPredicates,
         ResultPredicates<TResult> shouldHandleResultPredicates,
-        ICircuitController<TResult> breakerController)
+        ICircuitController<TResult> breakerController,
+        CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
 
diff --git a/src/Polly/CircuitBreaker/CircuitBreakerPolicy.cs b/src/Polly/CircuitBreaker/CircuitBreakerPolicy.cs
index c481848bb49..f4954804cc8 100644
--- a/src/Polly/CircuitBreaker/CircuitBreakerPolicy.cs
+++ b/src/Polly/CircuitBreaker/CircuitBreakerPolicy.cs
@@ -44,10 +44,10 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok
         CircuitBreakerEngine.Implementation<EmptyStruct>(
             (ctx, ct) => { result = action(ctx, ct); return EmptyStruct.Instance; },
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates<EmptyStruct>.None,
-            BreakerController);
+            BreakerController,
+            cancellationToken);
         return result;
     }
 }
@@ -101,8 +101,8 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
         CircuitBreakerEngine.Implementation(
             action,
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates,
-            BreakerController);
+            BreakerController,
+            cancellationToken);
 }
diff --git a/src/Polly/Fallback/AsyncFallbackEngine.cs b/src/Polly/Fallback/AsyncFallbackEngine.cs
index a13a8b3edf0..b0e9e48c740 100644
--- a/src/Polly/Fallback/AsyncFallbackEngine.cs
+++ b/src/Polly/Fallback/AsyncFallbackEngine.cs
@@ -6,12 +6,12 @@ internal class AsyncFallbackEngine
     internal static async Task<TResult> ImplementationAsync<TResult>(
         Func<Context, CancellationToken, Task<TResult>> action,
         Context context,
-        CancellationToken cancellationToken,
         ExceptionPredicates shouldHandleExceptionPredicates,
         ResultPredicates<TResult> shouldHandleResultPredicates,
         Func<DelegateResult<TResult>, Context, Task> onFallbackAsync,
         Func<DelegateResult<TResult>, Context, CancellationToken, Task<TResult>> fallbackAction,
-        bool continueOnCapturedContext)
+        bool continueOnCapturedContext,
+        CancellationToken cancellationToken)
     {
         DelegateResult<TResult> delegateOutcome;
 
diff --git a/src/Polly/Fallback/AsyncFallbackPolicy.cs b/src/Polly/Fallback/AsyncFallbackPolicy.cs
index 5c42f6dc59a..085329d946b 100644
--- a/src/Polly/Fallback/AsyncFallbackPolicy.cs
+++ b/src/Polly/Fallback/AsyncFallbackPolicy.cs
@@ -31,7 +31,6 @@ protected override Task ImplementationAsync(
                 return EmptyStruct.Instance;
             },
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates<EmptyStruct>.None,
             (outcome, ctx) => _onFallbackAsync(outcome.Exception, ctx),
@@ -40,7 +39,8 @@ protected override Task ImplementationAsync(
                 await _fallbackAction(outcome.Exception, ctx, ct).ConfigureAwait(continueOnCapturedContext);
                 return EmptyStruct.Instance;
             },
-            continueOnCapturedContext);
+            continueOnCapturedContext,
+            cancellationToken);
 
     /// <inheritdoc/>
     protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken,
@@ -77,10 +77,10 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT
         AsyncFallbackEngine.ImplementationAsync(
             action,
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates,
             _onFallbackAsync,
             _fallbackAction,
-            continueOnCapturedContext);
+            continueOnCapturedContext,
+            cancellationToken);
 }
diff --git a/src/Polly/Fallback/FallbackEngine.cs b/src/Polly/Fallback/FallbackEngine.cs
index bbbdd066cd4..3cf79a4dd5e 100644
--- a/src/Polly/Fallback/FallbackEngine.cs
+++ b/src/Polly/Fallback/FallbackEngine.cs
@@ -7,11 +7,11 @@ internal static class FallbackEngine
     internal static TResult Implementation<TResult>(
         Func<Context, CancellationToken, TResult> action,
         Context context,
-        CancellationToken cancellationToken,
         ExceptionPredicates shouldHandleExceptionPredicates,
         ResultPredicates<TResult> shouldHandleResultPredicates,
         Action<DelegateResult<TResult>, Context> onFallback,
-        Func<DelegateResult<TResult>, Context, CancellationToken, TResult> fallbackAction)
+        Func<DelegateResult<TResult>, Context, CancellationToken, TResult> fallbackAction,
+        CancellationToken cancellationToken)
     {
         DelegateResult<TResult> delegateOutcome;
 
diff --git a/src/Polly/Fallback/FallbackPolicy.cs b/src/Polly/Fallback/FallbackPolicy.cs
index 808f535263e..da2fb119e84 100644
--- a/src/Polly/Fallback/FallbackPolicy.cs
+++ b/src/Polly/Fallback/FallbackPolicy.cs
@@ -30,7 +30,6 @@ protected override void Implementation(Action<Context, CancellationToken> action
                 return EmptyStruct.Instance;
             },
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates<EmptyStruct>.None,
             (outcome, ctx) => _onFallback(outcome.Exception, ctx),
@@ -38,7 +37,8 @@ protected override void Implementation(Action<Context, CancellationToken> action
             {
                 _fallbackAction(outcome.Exception, ctx, ct);
                 return EmptyStruct.Instance;
-            });
+            },
+            cancellationToken);
 
     /// <inheritdoc/>
     protected override TResult Implementation<TResult>(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken) =>
@@ -73,9 +73,9 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
         FallbackEngine.Implementation(
             action,
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates,
             _onFallback,
-            _fallbackAction);
+            _fallbackAction,
+            cancellationToken);
 }
diff --git a/src/Polly/IAsyncPolicy.TResult.cs b/src/Polly/IAsyncPolicy.TResult.cs
index 3ac40611abc..340f63975f4 100644
--- a/src/Polly/IAsyncPolicy.TResult.cs
+++ b/src/Polly/IAsyncPolicy.TResult.cs
@@ -63,6 +63,7 @@ public interface IAsyncPolicy<TResult> : IsPolicy
     /// <returns>The value returned by the action.</returns>
     Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken);
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -72,7 +73,9 @@ public interface IAsyncPolicy<TResult> : IsPolicy
     /// <returns>The value returned by the action.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     Task<TResult> ExecuteAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -83,7 +86,9 @@ public interface IAsyncPolicy<TResult> : IsPolicy
     /// <returns>The value returned by the action.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="contextData"/> is <see langword="null"/>.</exception>
     Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -94,6 +99,7 @@ public interface IAsyncPolicy<TResult> : IsPolicy
     /// <returns>The value returned by the action.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
     /// <summary>
     /// Executes the specified asynchronous action within the policy and returns the result.
@@ -146,6 +152,7 @@ public interface IAsyncPolicy<TResult> : IsPolicy
     /// <returns>The captured result.</returns>
     Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken);
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -155,7 +162,9 @@ public interface IAsyncPolicy<TResult> : IsPolicy
     /// <returns>The captured result.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -166,7 +175,9 @@ public interface IAsyncPolicy<TResult> : IsPolicy
     /// <returns>The captured result.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="contextData"/> is <see langword="null"/>.</exception>
     Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -177,4 +188,5 @@ public interface IAsyncPolicy<TResult> : IsPolicy
     /// <returns>The captured result.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 }
diff --git a/src/Polly/IAsyncPolicy.cs b/src/Polly/IAsyncPolicy.cs
index 205770a5892..0d2cfba8d5b 100644
--- a/src/Polly/IAsyncPolicy.cs
+++ b/src/Polly/IAsyncPolicy.cs
@@ -62,6 +62,7 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>A <see cref="Task" /> which completes when <see cref="IAsyncPolicy"/> is registered.</returns>
     Task ExecuteAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken);
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy.
     /// </summary>
@@ -71,7 +72,9 @@ public interface IAsyncPolicy : IsPolicy
     /// <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="IAsyncPolicy"/> is registered.</returns>
     Task ExecuteAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy.
     /// </summary>
@@ -82,7 +85,9 @@ public interface IAsyncPolicy : IsPolicy
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="contextData"/> is <see langword="null"/>.</exception>
     /// <returns>A <see cref="Task" /> which completes when <see cref="IAsyncPolicy"/> is registered.</returns>
     Task ExecuteAsync(Func<Context, CancellationToken, Task> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy.
     /// </summary>
@@ -93,6 +98,7 @@ public interface IAsyncPolicy : IsPolicy
     /// <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="IAsyncPolicy"/> is registered.</returns>
     Task ExecuteAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
@@ -149,6 +155,7 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>The value returned by the action.</returns>
     Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken);
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -159,7 +166,9 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>The value returned by the action.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     Task<TResult> ExecuteAsync<TResult>(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -171,7 +180,9 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>The value returned by the action.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="contextData"/> is <see langword="null"/>.</exception>
     Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -183,6 +194,7 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>The value returned by the action.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the captured result.
@@ -235,6 +247,7 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>The captured result.</returns>
     Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken);
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the captured result.
     /// </summary>
@@ -244,7 +257,9 @@ public interface IAsyncPolicy : IsPolicy
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     /// <returns>An instance of <see cref="PolicyResult"/>.</returns>
     Task<PolicyResult> ExecuteAndCaptureAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the captured result.
     /// </summary>
@@ -255,7 +270,9 @@ public interface IAsyncPolicy : IsPolicy
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="contextData"/> is <see langword="null"/>.</exception>
     /// <returns>The captured result.</returns>
     Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the captured result.
     /// </summary>
@@ -266,6 +283,7 @@ public interface IAsyncPolicy : IsPolicy
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     /// <returns>The captured result.</returns>
     Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
     /// <summary>
     /// Executes the specified asynchronous action within the policy and returns the result.
@@ -324,6 +342,7 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>The captured result.</returns>
     Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken);
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -334,7 +353,9 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>The captured result.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -346,7 +367,9 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>The captured result.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="contextData"/> is <see langword="null"/>.</exception>
     Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 
+#pragma warning disable CA1068
     /// <summary>
     ///     Executes the specified asynchronous action within the policy and returns the result.
     /// </summary>
@@ -358,4 +381,5 @@ public interface IAsyncPolicy : IsPolicy
     /// <returns>The captured result.</returns>
     /// <exception cref="InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
     Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+#pragma warning restore CA1068
 }
diff --git a/src/Polly/Polly.csproj b/src/Polly/Polly.csproj
index 3f228b6c829..8e4e61f41c4 100644
--- a/src/Polly/Polly.csproj
+++ b/src/Polly/Polly.csproj
@@ -7,7 +7,7 @@
     <ProjectType>Library</ProjectType>
     <MutationScore>70</MutationScore>
     <IncludePollyUsings>true</IncludePollyUsings>
-    <NoWarn>$(NoWarn);CA1010;CA1031;CA1032;CA1033;CA1051;CA1062;CA1063;CA1064;CA1068;CA1710;CA1716;CA1724;CA1805;CA1815;CA1816;CA2211</NoWarn>
+    <NoWarn>$(NoWarn);CA1010;CA1031;CA1032;CA1033;CA1051;CA1062;CA1063;CA1064;CA1710;CA1716;CA1724;CA1805;CA1815;CA1816;CA2211</NoWarn>
     <NoWarn>$(NoWarn);S2223;S3215;S3246;S3971;S4039;S4049;S4457</NoWarn>
     <!--Public API Analyzers: We do not need to fix these as it would break compatibility with released Polly versions-->
     <NoWarn>$(NoWarn);RS0037;</NoWarn>
diff --git a/src/Polly/RateLimit/AsyncRateLimitEngine.cs b/src/Polly/RateLimit/AsyncRateLimitEngine.cs
index 0c31e6fcda7..c380335da2f 100644
--- a/src/Polly/RateLimit/AsyncRateLimitEngine.cs
+++ b/src/Polly/RateLimit/AsyncRateLimitEngine.cs
@@ -9,8 +9,8 @@ internal static async Task<TResult> ImplementationAsync<TResult>(
         Func<TimeSpan, Context, TResult>? retryAfterFactory,
         Func<Context, CancellationToken, Task<TResult>> action,
         Context context,
-        CancellationToken cancellationToken,
-        bool continueOnCapturedContext)
+        bool continueOnCapturedContext,
+        CancellationToken cancellationToken)
     {
         (bool permit, TimeSpan retryAfter) = rateLimiter.PermitExecution();
 
diff --git a/src/Polly/RateLimit/AsyncRateLimitPolicy.cs b/src/Polly/RateLimit/AsyncRateLimitPolicy.cs
index 0acec910a53..cb643e83be9 100644
--- a/src/Polly/RateLimit/AsyncRateLimitPolicy.cs
+++ b/src/Polly/RateLimit/AsyncRateLimitPolicy.cs
@@ -16,7 +16,7 @@ internal AsyncRateLimitPolicy(IRateLimiter rateLimiter) =>
     [DebuggerStepThrough]
     protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken,
         bool continueOnCapturedContext) =>
-        AsyncRateLimitEngine.ImplementationAsync(_rateLimiter, null, action, context, cancellationToken, continueOnCapturedContext);
+        AsyncRateLimitEngine.ImplementationAsync(_rateLimiter, null, action, context, continueOnCapturedContext, cancellationToken);
 }
 
 /// <summary>
@@ -40,5 +40,5 @@ internal AsyncRateLimitPolicy(
     [DebuggerStepThrough]
     protected override Task<TResult> ImplementationAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken,
         bool continueOnCapturedContext) =>
-        AsyncRateLimitEngine.ImplementationAsync(_rateLimiter, _retryAfterFactory, action, context, cancellationToken, continueOnCapturedContext);
+        AsyncRateLimitEngine.ImplementationAsync(_rateLimiter, _retryAfterFactory, action, context, continueOnCapturedContext, cancellationToken);
 }
diff --git a/src/Polly/Retry/AsyncRetryEngine.cs b/src/Polly/Retry/AsyncRetryEngine.cs
index 6580a49c169..7237366b8f2 100644
--- a/src/Polly/Retry/AsyncRetryEngine.cs
+++ b/src/Polly/Retry/AsyncRetryEngine.cs
@@ -6,10 +6,10 @@ internal static class AsyncRetryEngine
     internal static async Task<TResult> ImplementationAsync<TResult>(
         Func<Context, CancellationToken, Task<TResult>> action,
         Context context,
-        CancellationToken cancellationToken,
         ExceptionPredicates shouldRetryExceptionPredicates,
         ResultPredicates<TResult> shouldRetryResultPredicates,
         Func<DelegateResult<TResult>, TimeSpan, int, Context, Task> onRetryAsync,
+        CancellationToken cancellationToken,
         int permittedRetryCount = int.MaxValue,
         IEnumerable<TimeSpan>? sleepDurationsEnumerable = null,
         Func<int, DelegateResult<TResult>, Context, TimeSpan>? sleepDurationProvider = null,
diff --git a/src/Polly/Retry/AsyncRetryPolicy.cs b/src/Polly/Retry/AsyncRetryPolicy.cs
index bd8b6b4b0f5..195b5a4767b 100644
--- a/src/Polly/Retry/AsyncRetryPolicy.cs
+++ b/src/Polly/Retry/AsyncRetryPolicy.cs
@@ -40,10 +40,10 @@ protected override Task<TResult> ImplementationAsync<TResult>(
         return AsyncRetryEngine.ImplementationAsync(
             action,
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates<TResult>.None,
             (outcome, timespan, retryCount, ctx) => _onRetryAsync(outcome.Exception, timespan, retryCount, ctx),
+            cancellationToken,
             _permittedRetryCount,
             _sleepDurationsEnumerable,
             sleepDurationProvider,
@@ -83,10 +83,10 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT
         AsyncRetryEngine.ImplementationAsync(
             action,
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates,
             _onRetryAsync,
+            cancellationToken,
             _permittedRetryCount,
             _sleepDurationsEnumerable,
             _sleepDurationProvider,
diff --git a/src/Polly/Retry/RetryEngine.cs b/src/Polly/Retry/RetryEngine.cs
index 6a8000b5e53..966da9858d8 100644
--- a/src/Polly/Retry/RetryEngine.cs
+++ b/src/Polly/Retry/RetryEngine.cs
@@ -6,10 +6,10 @@ internal static class RetryEngine
     internal static TResult Implementation<TResult>(
         Func<Context, CancellationToken, TResult> action,
         Context context,
-        CancellationToken cancellationToken,
         ExceptionPredicates shouldRetryExceptionPredicates,
         ResultPredicates<TResult> shouldRetryResultPredicates,
         Action<DelegateResult<TResult>, TimeSpan, int, Context> onRetry,
+        CancellationToken cancellationToken,
         int permittedRetryCount = int.MaxValue,
         IEnumerable<TimeSpan>? sleepDurationsEnumerable = null,
         Func<int, DelegateResult<TResult>, Context, TimeSpan>? sleepDurationProvider = null)
diff --git a/src/Polly/Retry/RetryPolicy.cs b/src/Polly/Retry/RetryPolicy.cs
index 8662c5869bf..d85258b3ed4 100644
--- a/src/Polly/Retry/RetryPolicy.cs
+++ b/src/Polly/Retry/RetryPolicy.cs
@@ -34,10 +34,10 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok
 
         return RetryEngine.Implementation(action,
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates<TResult>.None,
             (outcome, timespan, retryCount, ctx) => _onRetry(outcome.Exception, timespan, retryCount, ctx),
+            cancellationToken,
             _permittedRetryCount,
             _sleepDurationsEnumerable,
             sleepDurationProvider);
@@ -75,10 +75,10 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
         RetryEngine.Implementation(
             action,
             context,
-            cancellationToken,
             ExceptionPredicates,
             ResultPredicates,
             _onRetry,
+            cancellationToken,
             _permittedRetryCount,
             _sleepDurationsEnumerable,
             _sleepDurationProvider);
diff --git a/src/Polly/Timeout/AsyncTimeoutEngine.cs b/src/Polly/Timeout/AsyncTimeoutEngine.cs
index d451964ec28..fc008c3b4fc 100644
--- a/src/Polly/Timeout/AsyncTimeoutEngine.cs
+++ b/src/Polly/Timeout/AsyncTimeoutEngine.cs
@@ -5,11 +5,11 @@ internal static class AsyncTimeoutEngine
     internal static async Task<TResult> ImplementationAsync<TResult>(
         Func<Context, CancellationToken, Task<TResult>> action,
         Context context,
-        CancellationToken cancellationToken,
         Func<Context, TimeSpan> timeoutProvider,
         TimeoutStrategy timeoutStrategy,
         Func<Context, TimeSpan, Task, Exception, Task> onTimeoutAsync,
-        bool continueOnCapturedContext)
+        bool continueOnCapturedContext,
+        CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
         TimeSpan timeout = timeoutProvider(context);
diff --git a/src/Polly/Timeout/AsyncTimeoutPolicy.cs b/src/Polly/Timeout/AsyncTimeoutPolicy.cs
index bccd01e82c5..ff7f6370a1b 100644
--- a/src/Polly/Timeout/AsyncTimeoutPolicy.cs
+++ b/src/Polly/Timeout/AsyncTimeoutPolicy.cs
@@ -29,11 +29,11 @@ protected override Task<TResult> ImplementationAsync<TResult>(
         AsyncTimeoutEngine.ImplementationAsync(
             action,
             context,
-            cancellationToken,
             _timeoutProvider,
             _timeoutStrategy,
             _onTimeoutAsync,
-            continueOnCapturedContext);
+            continueOnCapturedContext,
+            cancellationToken);
 }
 
 /// <summary>
@@ -66,9 +66,9 @@ protected override Task<TResult> ImplementationAsync(
         AsyncTimeoutEngine.ImplementationAsync(
             action,
             context,
-            cancellationToken,
             _timeoutProvider,
             _timeoutStrategy,
             _onTimeoutAsync,
-            continueOnCapturedContext);
+            continueOnCapturedContext,
+            cancellationToken);
 }
diff --git a/src/Polly/Timeout/TimeoutEngine.cs b/src/Polly/Timeout/TimeoutEngine.cs
index 199da1b4fab..2afbfd0685c 100644
--- a/src/Polly/Timeout/TimeoutEngine.cs
+++ b/src/Polly/Timeout/TimeoutEngine.cs
@@ -7,10 +7,10 @@ internal static class TimeoutEngine
     internal static TResult Implementation<TResult>(
         Func<Context, CancellationToken, TResult> action,
         Context context,
-        CancellationToken cancellationToken,
         Func<Context, TimeSpan> timeoutProvider,
         TimeoutStrategy timeoutStrategy,
-        Action<Context, TimeSpan, Task, Exception> onTimeout)
+        Action<Context, TimeSpan, Task, Exception> onTimeout,
+        CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
         TimeSpan timeout = timeoutProvider(context);
diff --git a/src/Polly/Timeout/TimeoutPolicy.cs b/src/Polly/Timeout/TimeoutPolicy.cs
index 179b37301db..52bcfc875b9 100644
--- a/src/Polly/Timeout/TimeoutPolicy.cs
+++ b/src/Polly/Timeout/TimeoutPolicy.cs
@@ -25,10 +25,10 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok
         TimeoutEngine.Implementation(
             action,
             context,
-            cancellationToken,
             _timeoutProvider,
             _timeoutStrategy,
-            _onTimeout);
+            _onTimeout,
+            cancellationToken);
 }
 
 /// <summary>
@@ -56,8 +56,8 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
         TimeoutEngine.Implementation(
             action,
             context,
-            cancellationToken,
             _timeoutProvider,
             _timeoutStrategy,
-            _onTimeout);
+            _onTimeout,
+            cancellationToken);
 }
diff --git a/src/Polly/Utilities/Wrappers/ResilienceContextFactory.cs b/src/Polly/Utilities/Wrappers/ResilienceContextFactory.cs
index b334db5c584..287b3681300 100644
--- a/src/Polly/Utilities/Wrappers/ResilienceContextFactory.cs
+++ b/src/Polly/Utilities/Wrappers/ResilienceContextFactory.cs
@@ -4,9 +4,9 @@ internal static class ResilienceContextFactory
 {
     public static ResilienceContext Create(
         Context context,
-        CancellationToken cancellationToken,
         bool continueOnCapturedContext,
-        out IDictionary<string, object> oldProperties)
+        out IDictionary<string, object> oldProperties,
+        CancellationToken cancellationToken)
     {
         var resilienceContext = ResilienceContextPool.Shared.Get(context.OperationKey, continueOnCapturedContext, cancellationToken);
         resilienceContext.Properties.SetProperties(context, out oldProperties);
diff --git a/src/Polly/Utilities/Wrappers/ResiliencePipelineAsyncPolicy.TResult.cs b/src/Polly/Utilities/Wrappers/ResiliencePipelineAsyncPolicy.TResult.cs
index cec45a858a2..9a32cb3df32 100644
--- a/src/Polly/Utilities/Wrappers/ResiliencePipelineAsyncPolicy.TResult.cs
+++ b/src/Polly/Utilities/Wrappers/ResiliencePipelineAsyncPolicy.TResult.cs
@@ -10,9 +10,9 @@ protected override async Task<TResult> ImplementationAsync(Func<Context, Cancell
     {
         var resilienceContext = ResilienceContextFactory.Create(
             context,
-            cancellationToken,
             continueOnCapturedContext,
-            out var oldProperties);
+            out var oldProperties,
+            cancellationToken);
 
         try
         {
diff --git a/src/Polly/Utilities/Wrappers/ResiliencePipelineAsyncPolicy.cs b/src/Polly/Utilities/Wrappers/ResiliencePipelineAsyncPolicy.cs
index 4548f4aa71f..319a4d60fe5 100644
--- a/src/Polly/Utilities/Wrappers/ResiliencePipelineAsyncPolicy.cs
+++ b/src/Polly/Utilities/Wrappers/ResiliencePipelineAsyncPolicy.cs
@@ -14,9 +14,9 @@ protected override async Task ImplementationAsync(
     {
         var resilienceContext = ResilienceContextFactory.Create(
             context,
-            cancellationToken,
             continueOnCapturedContext,
-            out var oldProperties);
+            out var oldProperties,
+            cancellationToken);
 
         try
         {
@@ -42,9 +42,9 @@ protected override async Task<TResult> ImplementationAsync<TResult>(
     {
         var resilienceContext = ResilienceContextFactory.Create(
             context,
-            cancellationToken,
             continueOnCapturedContext,
-            out var oldProperties);
+            out var oldProperties,
+            cancellationToken);
 
         try
         {
diff --git a/src/Polly/Utilities/Wrappers/ResiliencePipelineSyncPolicy.TResult.cs b/src/Polly/Utilities/Wrappers/ResiliencePipelineSyncPolicy.TResult.cs
index d4fca1c3e37..4ebce11e4b1 100644
--- a/src/Polly/Utilities/Wrappers/ResiliencePipelineSyncPolicy.TResult.cs
+++ b/src/Polly/Utilities/Wrappers/ResiliencePipelineSyncPolicy.TResult.cs
@@ -10,9 +10,9 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
     {
         var resilienceContext = ResilienceContextFactory.Create(
             context,
-            cancellationToken,
             true,
-            out var oldProperties);
+            out var oldProperties,
+            cancellationToken);
 
         try
         {
diff --git a/src/Polly/Utilities/Wrappers/ResiliencePipelineSyncPolicy.cs b/src/Polly/Utilities/Wrappers/ResiliencePipelineSyncPolicy.cs
index f63eda601ce..df752b4551e 100644
--- a/src/Polly/Utilities/Wrappers/ResiliencePipelineSyncPolicy.cs
+++ b/src/Polly/Utilities/Wrappers/ResiliencePipelineSyncPolicy.cs
@@ -10,9 +10,9 @@ protected override void Implementation(Action<Context, CancellationToken> action
     {
         var resilienceContext = ResilienceContextFactory.Create(
             context,
-            cancellationToken,
             true,
-            out var oldProperties);
+            out var oldProperties,
+            cancellationToken);
 
         try
         {
@@ -34,9 +34,9 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok
     {
         var resilienceContext = ResilienceContextFactory.Create(
             context,
-            cancellationToken,
             true,
-            out var oldProperties);
+            out var oldProperties,
+            cancellationToken);
 
         try
         {
diff --git a/src/Polly/Wrap/AsyncPolicyWrap.cs b/src/Polly/Wrap/AsyncPolicyWrap.cs
index f82adc34b57..acf2e8e6be3 100644
--- a/src/Polly/Wrap/AsyncPolicyWrap.cs
+++ b/src/Polly/Wrap/AsyncPolicyWrap.cs
@@ -35,10 +35,10 @@ protected override Task ImplementationAsync(
         AsyncPolicyWrapEngine.ImplementationAsync(
             action,
             context,
-            cancellationToken,
             continueOnCapturedContext,
             _outer,
-            _inner);
+            _inner,
+            cancellationToken);
 
     /// <inheritdoc/>
     [DebuggerStepThrough]
@@ -47,10 +47,10 @@ protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, Canc
         AsyncPolicyWrapEngine.ImplementationAsync<TResult>(
             action,
             context,
-            cancellationToken,
             continueOnCapturedContext,
             _outer,
-            _inner);
+            _inner,
+            cancellationToken);
 }
 
 /// <summary>
@@ -107,20 +107,20 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT
                 return AsyncPolicyWrapEngine.ImplementationAsync<TResult>(
                     action,
                     context,
-                    cancellationToken,
                     continueOnCapturedContext,
                     _outerNonGeneric,
-                    _innerNonGeneric);
+                    _innerNonGeneric,
+                    cancellationToken);
             }
             else if (_innerGeneric != null)
             {
                 return AsyncPolicyWrapEngine.ImplementationAsync<TResult>(
                     action,
                     context,
-                    cancellationToken,
                     continueOnCapturedContext,
                     _outerNonGeneric,
-                    _innerGeneric);
+                    _innerGeneric,
+                    cancellationToken);
 
             }
             else
@@ -135,10 +135,10 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT
                 return AsyncPolicyWrapEngine.ImplementationAsync<TResult>(
                     action,
                     context,
-                    cancellationToken,
                     continueOnCapturedContext,
                     _outerGeneric,
-                    _innerNonGeneric);
+                    _innerNonGeneric,
+                    cancellationToken);
 
             }
             else if (_innerGeneric != null)
@@ -146,10 +146,10 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT
                 return AsyncPolicyWrapEngine.ImplementationAsync<TResult>(
                     action,
                     context,
-                    cancellationToken,
                     continueOnCapturedContext,
                     _outerGeneric,
-                    _innerGeneric);
+                    _innerGeneric,
+                    cancellationToken);
 
             }
             else
diff --git a/src/Polly/Wrap/AsyncPolicyWrapEngine.cs b/src/Polly/Wrap/AsyncPolicyWrapEngine.cs
index 280aae85cab..6f7b2d78fd1 100644
--- a/src/Polly/Wrap/AsyncPolicyWrapEngine.cs
+++ b/src/Polly/Wrap/AsyncPolicyWrapEngine.cs
@@ -3,12 +3,12 @@
 internal static class AsyncPolicyWrapEngine
 {
     internal static Task<TResult> ImplementationAsync<TResult>(
-       Func<Context, CancellationToken, Task<TResult>> func,
+        Func<Context, CancellationToken, Task<TResult>> func,
         Context context,
-        CancellationToken cancellationToken,
         bool continueOnCapturedContext,
         IAsyncPolicy<TResult> outerPolicy,
-        IAsyncPolicy<TResult> innerPolicy) =>
+        IAsyncPolicy<TResult> innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.ExecuteAsync(
             (ctx, ct) => innerPolicy.ExecuteAsync(
                 func,
@@ -20,12 +20,12 @@ internal static Task<TResult> ImplementationAsync<TResult>(
             continueOnCapturedContext);
 
     internal static Task<TResult> ImplementationAsync<TResult>(
-       Func<Context, CancellationToken, Task<TResult>> func,
+        Func<Context, CancellationToken, Task<TResult>> func,
         Context context,
-        CancellationToken cancellationToken,
         bool continueOnCapturedContext,
         IAsyncPolicy<TResult> outerPolicy,
-        IAsyncPolicy innerPolicy) =>
+        IAsyncPolicy innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.ExecuteAsync(
             (ctx, ct) => innerPolicy.ExecuteAsync<TResult>(
                 func,
@@ -39,10 +39,10 @@ internal static Task<TResult> ImplementationAsync<TResult>(
     internal static Task<TResult> ImplementationAsync<TResult>(
         Func<Context, CancellationToken, Task<TResult>> func,
         Context context,
-        CancellationToken cancellationToken,
         bool continueOnCapturedContext,
         IAsyncPolicy outerPolicy,
-        IAsyncPolicy<TResult> innerPolicy) =>
+        IAsyncPolicy<TResult> innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.ExecuteAsync<TResult>(
             (ctx, ct) => innerPolicy.ExecuteAsync(
                 func,
@@ -54,12 +54,12 @@ internal static Task<TResult> ImplementationAsync<TResult>(
             continueOnCapturedContext);
 
     internal static Task<TResult> ImplementationAsync<TResult>(
-       Func<Context, CancellationToken, Task<TResult>> func,
-       Context context,
-       CancellationToken cancellationToken,
-       bool continueOnCapturedContext,
-       IAsyncPolicy outerPolicy,
-       IAsyncPolicy innerPolicy) =>
+        Func<Context, CancellationToken, Task<TResult>> func,
+        Context context,
+        bool continueOnCapturedContext,
+        IAsyncPolicy outerPolicy,
+        IAsyncPolicy innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.ExecuteAsync<TResult>(
             (ctx, ct) => innerPolicy.ExecuteAsync<TResult>(
                 func,
@@ -73,10 +73,10 @@ internal static Task<TResult> ImplementationAsync<TResult>(
     internal static Task ImplementationAsync(
         Func<Context, CancellationToken, Task> action,
         Context context,
-        CancellationToken cancellationToken,
         bool continueOnCapturedContext,
         IAsyncPolicy outerPolicy,
-        IAsyncPolicy innerPolicy) =>
+        IAsyncPolicy innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.ExecuteAsync(
             (ctx, ct) => innerPolicy.ExecuteAsync(
                 action,
diff --git a/src/Polly/Wrap/PolicyWrap.cs b/src/Polly/Wrap/PolicyWrap.cs
index f6bde0b768a..5c2dea29414 100644
--- a/src/Polly/Wrap/PolicyWrap.cs
+++ b/src/Polly/Wrap/PolicyWrap.cs
@@ -31,9 +31,9 @@ protected override void Implementation(Action<Context, CancellationToken> action
         PolicyWrapEngine.Implementation(
             action,
             context,
-            cancellationToken,
             _outer,
-            _inner);
+            _inner,
+            cancellationToken);
 
     /// <inheritdoc/>
     [DebuggerStepThrough]
@@ -41,9 +41,9 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok
         PolicyWrapEngine.Implementation<TResult>(
             action,
             context,
-            cancellationToken,
             _outer,
-            _inner);
+            _inner,
+            cancellationToken);
 }
 
 /// <summary>
@@ -99,18 +99,18 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
                 return PolicyWrapEngine.Implementation<TResult>(
                     action,
                     context,
-                    cancellationToken,
                     _outerNonGeneric,
-                    _innerNonGeneric);
+                    _innerNonGeneric,
+                    cancellationToken);
             }
             else if (_innerGeneric != null)
             {
                 return PolicyWrapEngine.Implementation<TResult>(
                     action,
                     context,
-                    cancellationToken,
                     _outerNonGeneric,
-                    _innerGeneric);
+                    _innerGeneric,
+                    cancellationToken);
             }
             else
             {
@@ -124,9 +124,9 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
                 return PolicyWrapEngine.Implementation<TResult>(
                     action,
                     context,
-                    cancellationToken,
                     _outerGeneric,
-                    _innerNonGeneric);
+                    _innerNonGeneric,
+                    cancellationToken);
 
             }
             else if (_innerGeneric != null)
@@ -134,9 +134,9 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
                 return PolicyWrapEngine.Implementation<TResult>(
                     action,
                     context,
-                    cancellationToken,
                     _outerGeneric,
-                    _innerGeneric);
+                    _innerGeneric,
+                    cancellationToken);
             }
             else
             {
diff --git a/src/Polly/Wrap/PolicyWrapEngine.cs b/src/Polly/Wrap/PolicyWrapEngine.cs
index 87409c84dbf..e88d06b2ce9 100644
--- a/src/Polly/Wrap/PolicyWrapEngine.cs
+++ b/src/Polly/Wrap/PolicyWrapEngine.cs
@@ -5,40 +5,40 @@ internal static class PolicyWrapEngine
     internal static TResult Implementation<TResult>(
         Func<Context, CancellationToken, TResult> func,
         Context context,
-        CancellationToken cancellationToken,
         ISyncPolicy<TResult> outerPolicy,
-        ISyncPolicy<TResult> innerPolicy) =>
+        ISyncPolicy<TResult> innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.Execute((ctx, ct) => innerPolicy.Execute(func, ctx, ct), context, cancellationToken);
 
     internal static TResult Implementation<TResult>(
-       Func<Context, CancellationToken, TResult> func,
-       Context context,
-       CancellationToken cancellationToken,
-       ISyncPolicy<TResult> outerPolicy,
-       ISyncPolicy innerPolicy) =>
+        Func<Context, CancellationToken, TResult> func,
+        Context context,
+        ISyncPolicy<TResult> outerPolicy,
+        ISyncPolicy innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.Execute((ctx, ct) => innerPolicy.Execute<TResult>(func, ctx, ct), context, cancellationToken);
 
     internal static TResult Implementation<TResult>(
-       Func<Context, CancellationToken, TResult> func,
-       Context context,
-       CancellationToken cancellationToken,
-       ISyncPolicy outerPolicy,
-       ISyncPolicy<TResult> innerPolicy) =>
+        Func<Context, CancellationToken, TResult> func,
+        Context context,
+        ISyncPolicy outerPolicy,
+        ISyncPolicy<TResult> innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.Execute<TResult>((ctx, ct) => innerPolicy.Execute(func, ctx, ct), context, cancellationToken);
 
     internal static TResult Implementation<TResult>(
-       Func<Context, CancellationToken, TResult> func,
-       Context context,
-       CancellationToken cancellationToken,
-       ISyncPolicy outerPolicy,
-       ISyncPolicy innerPolicy) =>
+        Func<Context, CancellationToken, TResult> func,
+        Context context,
+        ISyncPolicy outerPolicy,
+        ISyncPolicy innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.Execute<TResult>((ctx, ct) => innerPolicy.Execute<TResult>(func, ctx, ct), context, cancellationToken);
 
     internal static void Implementation(
-       Action<Context, CancellationToken> action,
-       Context context,
-       CancellationToken cancellationToken,
-       ISyncPolicy outerPolicy,
-       ISyncPolicy innerPolicy) =>
+        Action<Context, CancellationToken> action,
+        Context context,
+        ISyncPolicy outerPolicy,
+        ISyncPolicy innerPolicy,
+        CancellationToken cancellationToken) =>
         outerPolicy.Execute((ctx, ct) => innerPolicy.Execute(action, ctx, ct), context, cancellationToken);
 }