diff --git a/examples/ConsoleApp/FeatureFilters/AccountIdFilter.cs b/examples/ConsoleApp/FeatureFilters/AccountIdFilter.cs
index 3d236eed..1fd56d4a 100644
--- a/examples/ConsoleApp/FeatureFilters/AccountIdFilter.cs
+++ b/examples/ConsoleApp/FeatureFilters/AccountIdFilter.cs
@@ -6,7 +6,6 @@
 using Microsoft.FeatureManagement;
 using System;
 using System.Collections.Generic;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Consoto.Banking.AccountService.FeatureManagement
@@ -18,7 +17,7 @@ namespace Consoto.Banking.AccountService.FeatureManagement
     [FilterAlias("AccountId")]
     class AccountIdFilter : IContextualFeatureFilter<IAccountContext>
     {
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext featureEvaluationContext, IAccountContext accountContext, CancellationToken _)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext featureEvaluationContext, IAccountContext accountContext)
         {
             if (string.IsNullOrEmpty(accountContext?.AccountId))
             {
diff --git a/examples/ConsoleApp/Program.cs b/examples/ConsoleApp/Program.cs
index afe4c52f..e0ab1021 100644
--- a/examples/ConsoleApp/Program.cs
+++ b/examples/ConsoleApp/Program.cs
@@ -8,7 +8,6 @@
 using Microsoft.FeatureManagement.FeatureFilters;
 using System;
 using System.Collections.Generic;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Consoto.Banking.AccountService
@@ -59,7 +58,7 @@ public static async Task Main(string[] args)
                         AccountId = account
                     };
 
-                    bool enabled = await featureManager.IsEnabledAsync(FeatureName, accountServiceContext, CancellationToken.None);
+                    bool enabled = await featureManager.IsEnabledAsync(FeatureName, accountServiceContext);
 
                     //
                     // Output results
diff --git a/examples/FeatureFlagDemo/BrowserFilter.cs b/examples/FeatureFlagDemo/BrowserFilter.cs
index e33f58c7..efeb8e70 100644
--- a/examples/FeatureFlagDemo/BrowserFilter.cs
+++ b/examples/FeatureFlagDemo/BrowserFilter.cs
@@ -6,7 +6,6 @@
 using Microsoft.FeatureManagement;
 using System;
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace FeatureFlagDemo.FeatureManagement.FeatureFilters
@@ -24,7 +23,7 @@ public BrowserFilter(IHttpContextAccessor httpContextAccessor)
             _httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
         }
 
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, CancellationToken _)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
             BrowserFilterSettings settings = context.Parameters.Get<BrowserFilterSettings>() ?? new BrowserFilterSettings();
 
diff --git a/examples/FeatureFlagDemo/Controllers/HomeController.cs b/examples/FeatureFlagDemo/Controllers/HomeController.cs
index f2643099..c4363967 100644
--- a/examples/FeatureFlagDemo/Controllers/HomeController.cs
+++ b/examples/FeatureFlagDemo/Controllers/HomeController.cs
@@ -8,7 +8,6 @@
 using Microsoft.FeatureManagement;
 using Microsoft.FeatureManagement.Mvc;
 using System.Threading.Tasks;
-using System.Threading;
 
 namespace FeatureFlagDemo.Controllers
 {
@@ -22,16 +21,16 @@ public HomeController(IFeatureManagerSnapshot featureSnapshot)
         }
 
         [FeatureGate(MyFeatureFlags.Home)]
-        public Task<IActionResult> Index()
+        public IActionResult Index()
         {
             return View();
         }
 
-        public async Task<IActionResult> About(CancellationToken cancellationToken)
+        public async Task<IActionResult> About()
         {
             ViewData["Message"] = "Your application description page.";
 
-            if (await _featureManager.IsEnabledAsync(nameof(MyFeatureFlags.CustomViewData), cancellationToken))
+            if (await _featureManager.IsEnabledAsync(nameof(MyFeatureFlags.CustomViewData)))
             {
                 ViewData["Message"] = $"This is FANCY CONTENT you can see only if '{nameof(MyFeatureFlags.CustomViewData)}' is enabled.";
             };
diff --git a/examples/FeatureFlagDemo/HttpContextTargetingContextAccessor.cs b/examples/FeatureFlagDemo/HttpContextTargetingContextAccessor.cs
index 931be833..9f9c8964 100644
--- a/examples/FeatureFlagDemo/HttpContextTargetingContextAccessor.cs
+++ b/examples/FeatureFlagDemo/HttpContextTargetingContextAccessor.cs
@@ -6,7 +6,6 @@
 using System;
 using System.Collections.Generic;
 using System.Security.Claims;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace FeatureFlagDemo
@@ -24,7 +23,7 @@ public HttpContextTargetingContextAccessor(IHttpContextAccessor httpContextAcces
             _httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
         }
 
-        public ValueTask<TargetingContext> GetContextAsync(CancellationToken _)
+        public ValueTask<TargetingContext> GetContextAsync()
         {
             HttpContext httpContext = _httpContextAccessor.HttpContext;
 
diff --git a/examples/FeatureFlagDemo/SuperUserFilter.cs b/examples/FeatureFlagDemo/SuperUserFilter.cs
index 1e188704..25dc8e5f 100644
--- a/examples/FeatureFlagDemo/SuperUserFilter.cs
+++ b/examples/FeatureFlagDemo/SuperUserFilter.cs
@@ -2,14 +2,13 @@
 // Licensed under the MIT license.
 //
 using Microsoft.FeatureManagement;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace FeatureFlagDemo.FeatureManagement.FeatureFilters
 {
     public class SuperUserFilter : IFeatureFilter
     {
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, CancellationToken _)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
             return Task.FromResult(false);
         }
diff --git a/examples/TargetingConsoleApp/Program.cs b/examples/TargetingConsoleApp/Program.cs
index 15e35eb7..ad115215 100644
--- a/examples/TargetingConsoleApp/Program.cs
+++ b/examples/TargetingConsoleApp/Program.cs
@@ -9,7 +9,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Consoto.Banking.HelpDesk
@@ -63,7 +62,7 @@ public static async Task Main(string[] args)
                         Groups = user.Groups
                     };
 
-                    bool enabled = await featureManager.IsEnabledAsync(FeatureName, targetingContext, CancellationToken.None);
+                    bool enabled = await featureManager.IsEnabledAsync(FeatureName, targetingContext);
 
                     //
                     // Output results
diff --git a/src/Microsoft.FeatureManagement.AspNetCore/FeatureGateAttribute.cs b/src/Microsoft.FeatureManagement.AspNetCore/FeatureGateAttribute.cs
index 835cc1bd..c2573b8c 100644
--- a/src/Microsoft.FeatureManagement.AspNetCore/FeatureGateAttribute.cs
+++ b/src/Microsoft.FeatureManagement.AspNetCore/FeatureGateAttribute.cs
@@ -107,8 +107,8 @@ public override async Task OnActionExecutionAsync(ActionExecutingContext context
             //
             // Enabled state is determined by either 'any' or 'all' features being enabled.
             bool enabled = RequirementType == RequirementType.All ?
-                             await Features.All(async feature => await fm.IsEnabledAsync(feature, context.HttpContext.RequestAborted).ConfigureAwait(false)).ConfigureAwait(false) :
-                             await Features.Any(async feature => await fm.IsEnabledAsync(feature, context.HttpContext.RequestAborted).ConfigureAwait(false)).ConfigureAwait(false);
+                             await Features.All(async feature => await fm.IsEnabledAsync(feature).ConfigureAwait(false)) :
+                             await Features.Any(async feature => await fm.IsEnabledAsync(feature).ConfigureAwait(false));
 
             if (enabled)
             {
diff --git a/src/Microsoft.FeatureManagement.AspNetCore/FeatureGatedAsyncActionFilter.cs b/src/Microsoft.FeatureManagement.AspNetCore/FeatureGatedAsyncActionFilter.cs
index 80a68a7e..594620ae 100644
--- a/src/Microsoft.FeatureManagement.AspNetCore/FeatureGatedAsyncActionFilter.cs
+++ b/src/Microsoft.FeatureManagement.AspNetCore/FeatureGatedAsyncActionFilter.cs
@@ -30,7 +30,7 @@ public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionE
         {
             IFeatureManager featureManager = context.HttpContext.RequestServices.GetRequiredService<IFeatureManagerSnapshot>();
 
-            if (await featureManager.IsEnabledAsync(FeatureName, context.HttpContext.RequestAborted).ConfigureAwait(false))
+            if (await featureManager.IsEnabledAsync(FeatureName).ConfigureAwait(false))
             {
                 IServiceProvider serviceProvider = context.HttpContext.RequestServices.GetRequiredService<IServiceProvider>();
 
diff --git a/src/Microsoft.FeatureManagement.AspNetCore/TagHelpers/FeatureTagHelper.cs b/src/Microsoft.FeatureManagement.AspNetCore/TagHelpers/FeatureTagHelper.cs
index 651c0068..4a0da1e0 100644
--- a/src/Microsoft.FeatureManagement.AspNetCore/TagHelpers/FeatureTagHelper.cs
+++ b/src/Microsoft.FeatureManagement.AspNetCore/TagHelpers/FeatureTagHelper.cs
@@ -4,7 +4,6 @@
 using Microsoft.AspNetCore.Razor.TagHelpers;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement.Mvc.TagHelpers
@@ -56,8 +55,8 @@ public override async Task ProcessAsync(TagHelperContext context, TagHelperOutpu
                 IEnumerable<string> names = Name.Split(',').Select(n => n.Trim());
 
                 enabled = Requirement == RequirementType.All ?
-                    await names.All(async n => await _featureManager.IsEnabledAsync(n, CancellationToken.None).ConfigureAwait(false)).ConfigureAwait(false) :
-                    await names.Any(async n => await _featureManager.IsEnabledAsync(n, CancellationToken.None).ConfigureAwait(false)).ConfigureAwait(false);
+                    await names.All(async n => await _featureManager.IsEnabledAsync(n).ConfigureAwait(false)) :
+                    await names.Any(async n => await _featureManager.IsEnabledAsync(n).ConfigureAwait(false));
             }
 
             if (Negate)
diff --git a/src/Microsoft.FeatureManagement.AspNetCore/UseForFeatureExtensions.cs b/src/Microsoft.FeatureManagement.AspNetCore/UseForFeatureExtensions.cs
index c8562b7a..4774ee9b 100644
--- a/src/Microsoft.FeatureManagement.AspNetCore/UseForFeatureExtensions.cs
+++ b/src/Microsoft.FeatureManagement.AspNetCore/UseForFeatureExtensions.cs
@@ -57,7 +57,7 @@ public static IApplicationBuilder UseForFeature(this IApplicationBuilder app, st
                 {
                     IFeatureManager fm = context.RequestServices.GetRequiredService<IFeatureManagerSnapshot>();
 
-                    if (await fm.IsEnabledAsync(featureName, context.RequestAborted).ConfigureAwait(false))
+                    if (await fm.IsEnabledAsync(featureName).ConfigureAwait(false))
                     {
                         await branch(context).ConfigureAwait(false);
                     }
diff --git a/src/Microsoft.FeatureManagement/ConfigurationFeatureDefinitionProvider.cs b/src/Microsoft.FeatureManagement/ConfigurationFeatureDefinitionProvider.cs
index f51c301c..7697dd05 100644
--- a/src/Microsoft.FeatureManagement/ConfigurationFeatureDefinitionProvider.cs
+++ b/src/Microsoft.FeatureManagement/ConfigurationFeatureDefinitionProvider.cs
@@ -7,7 +7,6 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -45,7 +44,7 @@ public void Dispose()
             _changeSubscription = null;
         }
 
-        public Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName, CancellationToken _)
+        public Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName)
         {
             if (featureName == null)
             {
@@ -68,7 +67,7 @@ public Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName, Can
         // The async key word is necessary for creating IAsyncEnumerable.
         // The need to disable this warning occurs when implementaing async stream synchronously. 
 #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
-        public async IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync([EnumeratorCancellation] CancellationToken _)
+        public async IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync()
 #pragma warning restore CS1998
         {
             if (Interlocked.Exchange(ref _stale, 0) != 0)
diff --git a/src/Microsoft.FeatureManagement/ContextualFeatureFilterEvaluator.cs b/src/Microsoft.FeatureManagement/ContextualFeatureFilterEvaluator.cs
index b2e68082..baf9220a 100644
--- a/src/Microsoft.FeatureManagement/ContextualFeatureFilterEvaluator.cs
+++ b/src/Microsoft.FeatureManagement/ContextualFeatureFilterEvaluator.cs
@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement
@@ -16,7 +15,7 @@ namespace Microsoft.FeatureManagement
     class ContextualFeatureFilterEvaluator : IContextualFeatureFilter<object>
     {
         private IFeatureFilterMetadata _filter;
-        private Func<object, FeatureFilterEvaluationContext, object, CancellationToken, Task<bool>> _evaluateFunc;
+        private Func<object, FeatureFilterEvaluationContext, object, Task<bool>> _evaluateFunc;
 
         public ContextualFeatureFilterEvaluator(IFeatureFilterMetadata filter, Type appContextType)
         {
@@ -44,14 +43,14 @@ public ContextualFeatureFilterEvaluator(IFeatureFilterMetadata filter, Type appC
             _filter = filter;
         }
 
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext evaluationContext, object context, CancellationToken cancellationToken)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext evaluationContext, object context)
         {
             if (_evaluateFunc == null)
             {
                 return Task.FromResult(false);
             }
 
-            return _evaluateFunc(_filter, evaluationContext, context, cancellationToken);
+            return _evaluateFunc(_filter, evaluationContext, context);
         }
 
         public static bool IsContextualFilter(IFeatureFilterMetadata filter, Type appContextType)
@@ -73,7 +72,7 @@ private static Type GetContextualFilterInterface(IFeatureFilterMetadata filter,
             return targetInterface;
         }
 
-        private static Func<object, FeatureFilterEvaluationContext, object, CancellationToken, Task<bool>> TypeAgnosticEvaluate(Type filterType, MethodInfo method)
+        private static Func<object, FeatureFilterEvaluationContext, object, Task<bool>> TypeAgnosticEvaluate(Type filterType, MethodInfo method)
         {
             //
             // Get the generic version of the evaluation helper method
@@ -83,28 +82,21 @@ private static Func<object, FeatureFilterEvaluationContext, object, Cancellation
             //
             // Create a type specific version of the evaluation helper method
             MethodInfo constructedHelper = genericHelper.MakeGenericMethod
-                (filterType,
-                 method.GetParameters()[0].ParameterType,
-                 method.GetParameters()[1].ParameterType,
-                 method.GetParameters()[2].ParameterType,
-                 method.ReturnType);
+                (filterType, method.GetParameters()[0].ParameterType, method.GetParameters()[1].ParameterType, method.ReturnType);
 
             //
             // Invoke the method to get the func
             object typeAgnosticDelegate = constructedHelper.Invoke(null, new object[] { method });
 
-            return (Func<object, FeatureFilterEvaluationContext, object, CancellationToken, Task<bool>>)typeAgnosticDelegate;
+            return (Func<object, FeatureFilterEvaluationContext, object, Task<bool>>)typeAgnosticDelegate;
         }
 
-        private static Func<object, FeatureFilterEvaluationContext, object, CancellationToken, Task<bool>> GenericTypeAgnosticEvaluate<TTarget, TParam1, TParam2, TParam3, TReturn>(MethodInfo method)
+        private static Func<object, FeatureFilterEvaluationContext, object, Task<bool>> GenericTypeAgnosticEvaluate<TTarget, TParam1, TParam2, TReturn>(MethodInfo method)
         {
-            Func<TTarget, FeatureFilterEvaluationContext, TParam2, CancellationToken, Task<bool>> func =
-                (Func<TTarget, FeatureFilterEvaluationContext, TParam2, CancellationToken, Task<bool>>)
-                Delegate.CreateDelegate(typeof(Func<TTarget, FeatureFilterEvaluationContext, TParam2, CancellationToken, Task<bool>>), method);
+            Func<TTarget, FeatureFilterEvaluationContext, TParam2, Task<bool>> func = (Func<TTarget, FeatureFilterEvaluationContext, TParam2, Task<bool>>)Delegate.CreateDelegate
+                (typeof(Func<TTarget, FeatureFilterEvaluationContext, TParam2, Task<bool>>), method);
 
-            Func<object, FeatureFilterEvaluationContext, object, CancellationToken, Task<bool>> genericDelegate =
-                (object target, FeatureFilterEvaluationContext param1, object param2, CancellationToken param3) =>
-                    func((TTarget)target, param1, (TParam2)param2, param3);
+            Func<object, FeatureFilterEvaluationContext, object, Task<bool>> genericDelegate = (object target, FeatureFilterEvaluationContext param1, object param2) => func((TTarget)target, param1, (TParam2)param2);
 
             return genericDelegate;
         }
diff --git a/src/Microsoft.FeatureManagement/EmptySessionManager.cs b/src/Microsoft.FeatureManagement/EmptySessionManager.cs
index 7f09b910..fd4b3d3f 100644
--- a/src/Microsoft.FeatureManagement/EmptySessionManager.cs
+++ b/src/Microsoft.FeatureManagement/EmptySessionManager.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 //
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement
@@ -11,12 +10,12 @@ namespace Microsoft.FeatureManagement
     /// </summary>
     class EmptySessionManager : ISessionManager
     {
-        public Task SetAsync(string featureName, bool enabled, CancellationToken _)
+        public Task SetAsync(string featureName, bool enabled)
         {
             return Task.CompletedTask;
         }
 
-        public Task<bool?> GetAsync(string featureName, CancellationToken _)
+        public Task<bool?> GetAsync(string featureName)
         {
             return Task.FromResult((bool?)null);
         }
diff --git a/src/Microsoft.FeatureManagement/FeatureFilters/PercentageFilter.cs b/src/Microsoft.FeatureManagement/FeatureFilters/PercentageFilter.cs
index 1f672861..c7ea8840 100644
--- a/src/Microsoft.FeatureManagement/FeatureFilters/PercentageFilter.cs
+++ b/src/Microsoft.FeatureManagement/FeatureFilters/PercentageFilter.cs
@@ -4,7 +4,6 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using Microsoft.FeatureManagement.Utils;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement.FeatureFilters
@@ -41,9 +40,8 @@ public object BindParameters(IConfiguration filterParameters)
         /// Performs a percentage based evaluation to determine whether a feature is enabled.
         /// </summary>
         /// <param name="context">The feature evaluation context.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>True if the feature is enabled, false otherwise.</returns>
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, CancellationToken cancellationToken)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
             //
             // Check if prebound settings available, otherwise bind from parameters.
diff --git a/src/Microsoft.FeatureManagement/FeatureFilters/TimeWindowFilter.cs b/src/Microsoft.FeatureManagement/FeatureFilters/TimeWindowFilter.cs
index 48ac7b1c..884332b3 100644
--- a/src/Microsoft.FeatureManagement/FeatureFilters/TimeWindowFilter.cs
+++ b/src/Microsoft.FeatureManagement/FeatureFilters/TimeWindowFilter.cs
@@ -4,7 +4,6 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using System;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement.FeatureFilters
@@ -41,9 +40,8 @@ public object BindParameters(IConfiguration filterParameters)
         /// Evaluates whether a feature is enabled based on a configurable time window.
         /// </summary>
         /// <param name="context">The feature evaluation context.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>True if the feature is enabled, false otherwise.</returns>
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, CancellationToken cancellationToken)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
             //
             // Check if prebound settings available, otherwise bind from parameters.
diff --git a/src/Microsoft.FeatureManagement/FeatureManager.cs b/src/Microsoft.FeatureManagement/FeatureManager.cs
index 33188fe3..748375fb 100644
--- a/src/Microsoft.FeatureManagement/FeatureManager.cs
+++ b/src/Microsoft.FeatureManagement/FeatureManager.cs
@@ -11,7 +11,6 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -67,26 +66,24 @@ public FeatureManager(
             _parametersCache = new MemoryCache(new MemoryCacheOptions());
         }
 
-        public Task<bool> IsEnabledAsync(string feature, CancellationToken cancellationToken)
+        public Task<bool> IsEnabledAsync(string feature)
         {
-            return IsEnabledAsync<object>(feature, null, false, false, cancellationToken);
+            return IsEnabledAsync<object>(feature, null, false, false);
         }
 
-        public Task<bool> IsEnabledAsync<TContext>(string feature, TContext appContext, CancellationToken cancellationToken)
+        public Task<bool> IsEnabledAsync<TContext>(string feature, TContext appContext)
         {
-            return IsEnabledAsync(feature, appContext, true, false, cancellationToken);
+            return IsEnabledAsync(feature, appContext, true, false);
         }
 
-        public Task<bool> IsEnabledAsync<TContext>(string feature, TContext appContext, bool ignoreVariant, CancellationToken cancellationToken)
+        public Task<bool> IsEnabledAsync<TContext>(string feature, TContext appContext, bool ignoreVariant)
         {
-            return IsEnabledAsync(feature, appContext, true, ignoreVariant, cancellationToken);
+            return IsEnabledAsync(feature, appContext, true, ignoreVariant);
         }
 
-        public async IAsyncEnumerable<string> GetFeatureNamesAsync([EnumeratorCancellation] CancellationToken cancellationToken)
+        public async IAsyncEnumerable<string> GetFeatureNamesAsync()
         {
-            await foreach (FeatureDefinition featureDefintion in _featureDefinitionProvider
-                                .GetAllFeatureDefinitionsAsync(cancellationToken)
-                                .ConfigureAwait(false))
+            await foreach (FeatureDefinition featureDefintion in _featureDefinitionProvider.GetAllFeatureDefinitionsAsync().ConfigureAwait(false))
             {
                 yield return featureDefintion.Name;
             }
@@ -97,11 +94,11 @@ public void Dispose()
             _parametersCache.Dispose();
         }
 
-        private async Task<bool> IsEnabledAsync<TContext>(string feature, TContext appContext, bool useAppContext, bool ignoreVariant, CancellationToken cancellationToken)
+        private async Task<bool> IsEnabledAsync<TContext>(string feature, TContext appContext, bool useAppContext, bool ignoreVariant)
         {
             foreach (ISessionManager sessionManager in _sessionManagers)
             {
-                bool? readSessionResult = await sessionManager.GetAsync(feature, cancellationToken).ConfigureAwait(false);
+                bool? readSessionResult = await sessionManager.GetAsync(feature).ConfigureAwait(false);
 
                 if (readSessionResult.HasValue)
                 {
@@ -111,9 +108,7 @@ private async Task<bool> IsEnabledAsync<TContext>(string feature, TContext appCo
 
             bool enabled;
 
-            FeatureDefinition featureDefinition = await _featureDefinitionProvider
-                .GetFeatureDefinitionAsync(feature, cancellationToken)
-                .ConfigureAwait(false);
+            FeatureDefinition featureDefinition = await _featureDefinitionProvider.GetFeatureDefinitionAsync(feature).ConfigureAwait(false);
 
             if (featureDefinition != null)
             {
@@ -195,7 +190,7 @@ private async Task<bool> IsEnabledAsync<TContext>(string feature, TContext appCo
                             BindSettings(filter, context, filterIndex);
 
                             if (contextualFilter != null &&
-                                await contextualFilter.EvaluateAsync(context, appContext, cancellationToken).ConfigureAwait(false) == targetEvaluation)
+                                await contextualFilter.EvaluateAsync(context, appContext).ConfigureAwait(false) == targetEvaluation)
                             {
                                 enabled = targetEvaluation;
 
@@ -209,7 +204,7 @@ await contextualFilter.EvaluateAsync(context, appContext, cancellationToken).Con
                         {
                             BindSettings(filter, context, filterIndex);
 
-                            if (await featureFilter.EvaluateAsync(context, cancellationToken).ConfigureAwait(false) == targetEvaluation)
+                            if (await featureFilter.EvaluateAsync(context).ConfigureAwait(false) == targetEvaluation)
                             {
                                 enabled = targetEvaluation;
 
@@ -221,7 +216,7 @@ await contextualFilter.EvaluateAsync(context, appContext, cancellationToken).Con
 
                 if (!ignoreVariant && (featureDefinition.Variants?.Any() ?? false) && featureDefinition.Status != Status.Disabled)
                 {
-                    FeatureVariant featureVariant = await GetFeatureVariantAsync(featureDefinition, appContext as TargetingContext, useAppContext, enabled, cancellationToken);
+                    FeatureVariant featureVariant = await GetFeatureVariantAsync(featureDefinition, appContext as TargetingContext, useAppContext, enabled, CancellationToken.None);
 
                     if (featureVariant != null)
                     {
@@ -252,7 +247,7 @@ await contextualFilter.EvaluateAsync(context, appContext, cancellationToken).Con
 
             foreach (ISessionManager sessionManager in _sessionManagers)
             {
-                await sessionManager.SetAsync(feature, enabled, cancellationToken).ConfigureAwait(false);
+                await sessionManager.SetAsync(feature, enabled).ConfigureAwait(false);
             }
 
             return enabled;
@@ -281,7 +276,7 @@ public ValueTask<Variant> GetVariantAsync(string feature, TargetingContext conte
         private async ValueTask<Variant> GetVariantAsync(string feature, TargetingContext context, bool useContext, CancellationToken cancellationToken)
         {
             FeatureDefinition featureDefinition = await _featureDefinitionProvider
-                .GetFeatureDefinitionAsync(feature, cancellationToken)
+                .GetFeatureDefinitionAsync(feature)
                 .ConfigureAwait(false);
 
             if (featureDefinition == null)
@@ -300,7 +295,7 @@ private async ValueTask<Variant> GetVariantAsync(string feature, TargetingContex
 
             FeatureVariant featureVariant;
 
-            bool isFeatureEnabled = await IsEnabledAsync(feature, context, true, cancellationToken).ConfigureAwait(false);
+            bool isFeatureEnabled = await IsEnabledAsync(feature, context, true).ConfigureAwait(false);
 
             featureVariant = await GetFeatureVariantAsync(featureDefinition, context, useContext, isFeatureEnabled, cancellationToken).ConfigureAwait(false);
 
@@ -365,7 +360,7 @@ private async ValueTask<FeatureVariant> GetFeatureVariantAsync(FeatureDefinition
                 {
                     //
                     // Acquire targeting context via accessor
-                    context = await _contextAccessor.GetContextAsync(cancellationToken).ConfigureAwait(false);
+                    context = await _contextAccessor.GetContextAsync().ConfigureAwait(false);
 
                     //
                     // Ensure targeting can be performed
diff --git a/src/Microsoft.FeatureManagement/FeatureManagerSnapshot.cs b/src/Microsoft.FeatureManagement/FeatureManagerSnapshot.cs
index 6934a83b..1f8d7516 100644
--- a/src/Microsoft.FeatureManagement/FeatureManagerSnapshot.cs
+++ b/src/Microsoft.FeatureManagement/FeatureManagerSnapshot.cs
@@ -5,7 +5,6 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -26,13 +25,13 @@ public FeatureManagerSnapshot(FeatureManager featureManager)
             _featureManager = featureManager ?? throw new ArgumentNullException(nameof(featureManager));
         }
 
-        public async IAsyncEnumerable<string> GetFeatureNamesAsync([EnumeratorCancellation]CancellationToken cancellationToken)
+        public async IAsyncEnumerable<string> GetFeatureNamesAsync()
         {
             if (_featureNames == null)
             {
                 var featureNames = new List<string>();
 
-                await foreach (string featureName in _featureManager.GetFeatureNamesAsync(cancellationToken).ConfigureAwait(false))
+                await foreach (string featureName in _featureManager.GetFeatureNamesAsync().ConfigureAwait(false))
                 {
                     featureNames.Add(featureName);
                 }
@@ -46,18 +45,18 @@ public async IAsyncEnumerable<string> GetFeatureNamesAsync([EnumeratorCancellati
             }
         }
 
-        public Task<bool> IsEnabledAsync(string feature, CancellationToken cancellationToken)
+        public Task<bool> IsEnabledAsync(string feature)
         {
             return _flagCache.GetOrAdd(
                 feature,
-                (key) => _featureManager.IsEnabledAsync(key, cancellationToken));
+                (key) => _featureManager.IsEnabledAsync(key));
         }
 
-        public Task<bool> IsEnabledAsync<TContext>(string feature, TContext context, CancellationToken cancellationToken)
+        public Task<bool> IsEnabledAsync<TContext>(string feature, TContext context)
         {
             return _flagCache.GetOrAdd(
                 feature,
-                (key) => _featureManager.IsEnabledAsync(key, context, cancellationToken));
+                (key) => _featureManager.IsEnabledAsync(key, context));
         }
 
         public async ValueTask<Variant> GetVariantAsync(string feature, CancellationToken cancellationToken)
diff --git a/src/Microsoft.FeatureManagement/IContextualFeatureFilter.cs b/src/Microsoft.FeatureManagement/IContextualFeatureFilter.cs
index 84deb352..64586334 100644
--- a/src/Microsoft.FeatureManagement/IContextualFeatureFilter.cs
+++ b/src/Microsoft.FeatureManagement/IContextualFeatureFilter.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 //
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement
@@ -19,8 +18,7 @@ public interface IContextualFeatureFilter<TContext> : IFeatureFilterMetadata
         /// </summary>
         /// <param name="featureFilterContext">A feature filter evaluation context that contains information that may be needed to evaluate the filter. This context includes configuration, if any, for this filter for the feature being evaluated.</param>
         /// <param name="appContext">A context defined by the application that is passed in to the feature management system to provide contextual information for evaluating a feature's state.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>True if the filter's criteria has been met, false otherwise.</returns>
-        Task<bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, TContext appContext, CancellationToken cancellationToken);
+        Task<bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, TContext appContext);
     }
 }
diff --git a/src/Microsoft.FeatureManagement/IFeatureDefinitionProvider.cs b/src/Microsoft.FeatureManagement/IFeatureDefinitionProvider.cs
index 3b5adc15..bc4895b9 100644
--- a/src/Microsoft.FeatureManagement/IFeatureDefinitionProvider.cs
+++ b/src/Microsoft.FeatureManagement/IFeatureDefinitionProvider.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 //
 using System.Collections.Generic;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement
@@ -16,15 +15,13 @@ public interface IFeatureDefinitionProvider
         /// Retrieves the definition for a given feature.
         /// </summary>
         /// <param name="featureName">The name of the feature to retrieve the definition for.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>The feature's definition.</returns>	
-        Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName, CancellationToken cancellationToken);
+        Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName);
 
         /// <summary>
         /// Retrieves definitions for all features.
         /// </summary>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>An enumerator which provides asynchronous iteration over feature definitions.</returns>
-        IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync(CancellationToken cancellationToken);
+        IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync();
     }
 }
diff --git a/src/Microsoft.FeatureManagement/IFeatureFilter.cs b/src/Microsoft.FeatureManagement/IFeatureFilter.cs
index 865a40dc..e6d914df 100644
--- a/src/Microsoft.FeatureManagement/IFeatureFilter.cs
+++ b/src/Microsoft.FeatureManagement/IFeatureFilter.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 //
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement
@@ -15,8 +14,7 @@ public interface IFeatureFilter : IFeatureFilterMetadata
         /// Evaluates the feature filter to see if the filter's criteria for being enabled has been satisfied.
         /// </summary>
         /// <param name="context">A feature filter evaluation context that contains information that may be needed to evaluate the filter. This context includes configuration, if any, for this filter for the feature being evaluated.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>True if the filter's criteria has been met, false otherwise.</returns>
-        Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, CancellationToken cancellationToken);
+        Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context);
     }
 }
diff --git a/src/Microsoft.FeatureManagement/IFeatureManager.cs b/src/Microsoft.FeatureManagement/IFeatureManager.cs
index d9b07e6a..374c4548 100644
--- a/src/Microsoft.FeatureManagement/IFeatureManager.cs
+++ b/src/Microsoft.FeatureManagement/IFeatureManager.cs
@@ -15,25 +15,22 @@ public interface IFeatureManager
         /// <summary>
         /// Retrieves a list of feature names registered in the feature manager.
         /// </summary>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>An enumerator which provides asynchronous iteration over the feature names registered in the feature manager.</returns>
-        IAsyncEnumerable<string> GetFeatureNamesAsync(CancellationToken cancellationToken);
+        IAsyncEnumerable<string> GetFeatureNamesAsync();
 
         /// <summary>
         /// Checks whether a given feature is enabled.
         /// </summary>
         /// <param name="feature">The name of the feature to check.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>True if the feature is enabled, otherwise false.</returns>
-        Task<bool> IsEnabledAsync(string feature, CancellationToken cancellationToken);
+        Task<bool> IsEnabledAsync(string feature);
 
         /// <summary>
         /// Checks whether a given feature is enabled.
         /// </summary>
         /// <param name="feature">The name of the feature to check.</param>
         /// <param name="context">A context providing information that can be used to evaluate whether a feature should be on or off.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>True if the feature is enabled, otherwise false.</returns>
-        Task<bool> IsEnabledAsync<TContext>(string feature, TContext context, CancellationToken cancellationToken);
+        Task<bool> IsEnabledAsync<TContext>(string feature, TContext context);
     }
 }
diff --git a/src/Microsoft.FeatureManagement/ISessionManager.cs b/src/Microsoft.FeatureManagement/ISessionManager.cs
index 1c0656f1..67189375 100644
--- a/src/Microsoft.FeatureManagement/ISessionManager.cs
+++ b/src/Microsoft.FeatureManagement/ISessionManager.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 //
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement
@@ -16,15 +15,13 @@ public interface ISessionManager
         /// </summary>
         /// <param name="featureName">The name of the feature.</param>
         /// <param name="enabled">The state of the feature.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
-        Task SetAsync(string featureName, bool enabled, CancellationToken cancellationToken);
+        Task SetAsync(string featureName, bool enabled);
 
         /// <summary>
         /// Queries the session manager for the session's feature state, if any, for the given feature.
         /// </summary>
         /// <param name="featureName">The name of the feature.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>The state of the feature if it is present in the session, otherwise null.</returns>
-        Task<bool?> GetAsync(string featureName, CancellationToken cancellationToken);
+        Task<bool?> GetAsync(string featureName);
     }
 }
diff --git a/src/Microsoft.FeatureManagement/IVariantFeatureManager.cs b/src/Microsoft.FeatureManagement/IVariantFeatureManager.cs
index cd0a2ddc..8f651c69 100644
--- a/src/Microsoft.FeatureManagement/IVariantFeatureManager.cs
+++ b/src/Microsoft.FeatureManagement/IVariantFeatureManager.cs
@@ -13,18 +13,16 @@ public interface IVariantFeatureManager
         /// Checks whether a given feature is enabled.
         /// </summary>
         /// <param name="feature">The name of the feature to check.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>True if the feature is enabled, otherwise false.</returns>
-        Task<bool> IsEnabledAsync(string feature, CancellationToken cancellationToken = default);
+        Task<bool> IsEnabledAsync(string feature);
 
         /// <summary>
         /// Checks whether a given feature is enabled.
         /// </summary>
         /// <param name="feature">The name of the feature to check.</param>
         /// <param name="context">A context providing information that can be used to evaluate whether a feature should be on or off.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>True if the feature is enabled, otherwise false.</returns>
-        Task<bool> IsEnabledAsync<TContext>(string feature, TContext context, CancellationToken cancellationToken = default);
+        Task<bool> IsEnabledAsync<TContext>(string feature, TContext context);
 
         /// <summary>
         /// Gets the assigned variant for a specfic feature.
diff --git a/src/Microsoft.FeatureManagement/Targeting/ContextualTargetingFilter.cs b/src/Microsoft.FeatureManagement/Targeting/ContextualTargetingFilter.cs
index 874f16f9..34633749 100644
--- a/src/Microsoft.FeatureManagement/Targeting/ContextualTargetingFilter.cs
+++ b/src/Microsoft.FeatureManagement/Targeting/ContextualTargetingFilter.cs
@@ -6,7 +6,6 @@
 using Microsoft.Extensions.Options;
 using Microsoft.FeatureManagement.Targeting;
 using System;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement.FeatureFilters
@@ -47,10 +46,9 @@ public object BindParameters(IConfiguration filterParameters)
         /// </summary>
         /// <param name="context">The feature evaluation context.</param>
         /// <param name="targetingContext">The targeting context to use during targeting evaluation.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <exception cref="ArgumentNullException">Thrown if either <paramref name="context"/> or <paramref name="targetingContext"/> is null.</exception>
         /// <returns>True if the feature is enabled, false otherwise.</returns>
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, ITargetingContext targetingContext, CancellationToken cancellationToken)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, ITargetingContext targetingContext)
         {
             if (context == null)
             {
diff --git a/src/Microsoft.FeatureManagement/Targeting/ITargetingContextAccessor.cs b/src/Microsoft.FeatureManagement/Targeting/ITargetingContextAccessor.cs
index 2739e628..94c1eebd 100644
--- a/src/Microsoft.FeatureManagement/Targeting/ITargetingContextAccessor.cs
+++ b/src/Microsoft.FeatureManagement/Targeting/ITargetingContextAccessor.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 //
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement.FeatureFilters
@@ -14,8 +13,7 @@ public interface ITargetingContextAccessor
         /// <summary>
         /// Retrieves the current targeting context.
         /// </summary>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <returns>The current targeting context.</returns>
-        ValueTask<TargetingContext> GetContextAsync(CancellationToken cancellationToken);
+        ValueTask<TargetingContext> GetContextAsync();
     }
 }
diff --git a/src/Microsoft.FeatureManagement/Targeting/TargetingFilter.cs b/src/Microsoft.FeatureManagement/Targeting/TargetingFilter.cs
index 4e92205a..d57e4b31 100644
--- a/src/Microsoft.FeatureManagement/Targeting/TargetingFilter.cs
+++ b/src/Microsoft.FeatureManagement/Targeting/TargetingFilter.cs
@@ -5,7 +5,6 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using System;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement.FeatureFilters
@@ -48,10 +47,9 @@ public object BindParameters(IConfiguration filterParameters)
         /// Performs a targeting evaluation using the current <see cref="TargetingContext"/> to determine if a feature should be enabled.
         /// </summary>
         /// <param name="context">The feature evaluation context.</param>
-        /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="context"/> is null.</exception>
         /// <returns>True if the feature is enabled, false otherwise.</returns>
-        public async Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, CancellationToken cancellationToken)
+        public async Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
             if (context == null)
             {
@@ -60,7 +58,7 @@ public async Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, Ca
 
             //
             // Acquire targeting context via accessor
-            TargetingContext targetingContext = await _contextAccessor.GetContextAsync(cancellationToken).ConfigureAwait(false);
+            TargetingContext targetingContext = await _contextAccessor.GetContextAsync().ConfigureAwait(false);
 
             //
             // Ensure targeting can be performed
@@ -73,7 +71,7 @@ public async Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, Ca
 
             //
             // Utilize contextual filter for targeting evaluation
-            return await _contextualFilter.EvaluateAsync(context, targetingContext, cancellationToken).ConfigureAwait(false);
+            return await _contextualFilter.EvaluateAsync(context, targetingContext).ConfigureAwait(false);
         }
     }
 }
diff --git a/tests/Tests.FeatureManagement/ContextualTestFilter.cs b/tests/Tests.FeatureManagement/ContextualTestFilter.cs
index 91bd6222..4bad3010 100644
--- a/tests/Tests.FeatureManagement/ContextualTestFilter.cs
+++ b/tests/Tests.FeatureManagement/ContextualTestFilter.cs
@@ -3,7 +3,6 @@
 //
 using Microsoft.FeatureManagement;
 using System;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Tests.FeatureManagement
@@ -12,7 +11,7 @@ class ContextualTestFilter : IContextualFeatureFilter<IAccountContext>
     {
         public Func<FeatureFilterEvaluationContext, IAccountContext, bool> ContextualCallback { get; set; }
 
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, IAccountContext accountContext, CancellationToken _)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, IAccountContext accountContext)
         {
             return Task.FromResult(ContextualCallback?.Invoke(context, accountContext) ?? false);
         }
diff --git a/tests/Tests.FeatureManagement/CustomTargetingFilter.cs b/tests/Tests.FeatureManagement/CustomTargetingFilter.cs
index daf970fd..8e29feb8 100644
--- a/tests/Tests.FeatureManagement/CustomTargetingFilter.cs
+++ b/tests/Tests.FeatureManagement/CustomTargetingFilter.cs
@@ -24,9 +24,9 @@ public CustomTargetingFilter(IOptions<TargetingEvaluationOptions> options, ILogg
 
         public Func<FeatureFilterEvaluationContext, Task<bool>> Callback { get; set; }
 
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, CancellationToken cancellationToken)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
-            return _contextualFilter.EvaluateAsync(context, new TargetingContext(){ UserId = "Jeff" }, cancellationToken);
+            return _contextualFilter.EvaluateAsync(context, new TargetingContext(){ UserId = "Jeff" });
         }
     }
 }
diff --git a/tests/Tests.FeatureManagement/FeatureManagement.cs b/tests/Tests.FeatureManagement/FeatureManagement.cs
index 483ea799..d9176c23 100644
--- a/tests/Tests.FeatureManagement/FeatureManagement.cs
+++ b/tests/Tests.FeatureManagement/FeatureManagement.cs
@@ -15,7 +15,6 @@
 using System.Linq;
 using System.Net;
 using System.Net.Http;
-using System.Threading;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -44,9 +43,9 @@ public async Task ReadsConfiguration()
 
             IFeatureManager featureManager = serviceProvider.GetRequiredService<IFeatureManager>();
 
-            Assert.True(await featureManager.IsEnabledAsync(OnFeature, CancellationToken.None));
+            Assert.True(await featureManager.IsEnabledAsync(OnFeature));
 
-            Assert.False(await featureManager.IsEnabledAsync(OffFeature, CancellationToken.None));
+            Assert.False(await featureManager.IsEnabledAsync(OffFeature));
 
             IEnumerable<IFeatureFilterMetadata> featureFilters = serviceProvider.GetRequiredService<IEnumerable<IFeatureFilterMetadata>>();
 
@@ -67,7 +66,7 @@ public async Task ReadsConfiguration()
                 return Task.FromResult(true);
             };
 
-            await featureManager.IsEnabledAsync(ConditionalFeature, CancellationToken.None);
+            await featureManager.IsEnabledAsync(ConditionalFeature);
 
             Assert.True(called);
         }
@@ -281,10 +280,10 @@ public async Task TimeWindow()
 
             IFeatureManager featureManager = provider.GetRequiredService<IFeatureManager>();
 
-            Assert.True(await featureManager.IsEnabledAsync(feature1, CancellationToken.None));
-            Assert.False(await featureManager.IsEnabledAsync(feature2, CancellationToken.None));
-            Assert.True(await featureManager.IsEnabledAsync(feature3, CancellationToken.None));
-            Assert.False(await featureManager.IsEnabledAsync(feature4, CancellationToken.None));
+            Assert.True(await featureManager.IsEnabledAsync(feature1));
+            Assert.False(await featureManager.IsEnabledAsync(feature2));
+            Assert.True(await featureManager.IsEnabledAsync(feature3));
+            Assert.False(await featureManager.IsEnabledAsync(feature4));
         }
 
         [Fact]
@@ -311,7 +310,7 @@ public async Task Percentage()
 
             for (int i = 0; i < 10; i++)
             {
-                if (await featureManager.IsEnabledAsync(feature1, CancellationToken.None))
+                if (await featureManager.IsEnabledAsync(feature1))
                 {
                     enabledCount++;
                 }
@@ -349,21 +348,21 @@ public async Task Targeting()
             Assert.True(await featureManager.IsEnabledAsync(targetingTestFeature, new TargetingContext
             {
                 UserId = "Jeff"
-            }, CancellationToken.None));
+            }));
 
             //
             // Not targeted by user id, but targeted by default rollout
             Assert.True(await featureManager.IsEnabledAsync(targetingTestFeature, new TargetingContext
             {
                 UserId = "Anne"
-            }, CancellationToken.None));
+            }));
 
             //
             // Not targeted by user id or default rollout
             Assert.False(await featureManager.IsEnabledAsync(targetingTestFeature, new TargetingContext
             {
                 UserId = "Patty"
-            }, CancellationToken.None));
+            }));
 
             //
             // Targeted by group rollout
@@ -371,7 +370,7 @@ public async Task Targeting()
             {
                 UserId = "Patty",
                 Groups = new List<string>() { "Ring1" }
-            }, CancellationToken.None));
+            }));
 
             //
             // Not targeted by user id, default rollout or group rollout
@@ -379,7 +378,7 @@ public async Task Targeting()
             {
                 UserId = "Isaac",
                 Groups = new List<string>() { "Ring1" }
-            }, CancellationToken.None));
+            }));
         }
 
         [Fact]
@@ -417,7 +416,7 @@ public async Task TargetingAccessor()
                 UserId = "Jeff"
             };
 
-            Assert.True(await featureManager.IsEnabledAsync(beta, CancellationToken.None));
+            Assert.True(await featureManager.IsEnabledAsync(beta));
 
             //
             // Not targeted by user id or default rollout
@@ -426,7 +425,7 @@ public async Task TargetingAccessor()
                 UserId = "Patty"
             };
 
-            Assert.False(await featureManager.IsEnabledAsync(beta, CancellationToken.None));
+            Assert.False(await featureManager.IsEnabledAsync(beta));
         }
 
         [Fact]
@@ -459,11 +458,11 @@ public async Task UsesContext()
 
             context.AccountId = "NotEnabledAccount";
 
-            Assert.False(await featureManager.IsEnabledAsync(ContextualFeature, context, CancellationToken.None));
+            Assert.False(await featureManager.IsEnabledAsync(ContextualFeature, context));
 
             context.AccountId = "abc";
 
-            Assert.True(await featureManager.IsEnabledAsync(ContextualFeature, context, CancellationToken.None));
+            Assert.True(await featureManager.IsEnabledAsync(ContextualFeature, context));
         }
 
         [Fact]
@@ -505,7 +504,7 @@ public async Task ListsFeatures()
 
                 bool hasItems = false;
 
-                await foreach (string feature in featureManager.GetFeatureNamesAsync(CancellationToken.None))
+                await foreach (string feature in featureManager.GetFeatureNamesAsync())
                 {
                     hasItems = true;
 
@@ -531,8 +530,7 @@ public async Task ThrowsExceptionForMissingFeatureFilter()
 
             IFeatureManager featureManager = serviceProvider.GetRequiredService<IFeatureManager>();
 
-            FeatureManagementException e = await Assert.ThrowsAsync<FeatureManagementException>(
-                async () => await featureManager.IsEnabledAsync(ConditionalFeature, CancellationToken.None));
+            FeatureManagementException e = await Assert.ThrowsAsync<FeatureManagementException>(async () => await featureManager.IsEnabledAsync(ConditionalFeature));
 
             Assert.Equal(FeatureManagementError.MissingFeatureFilter, e.Error);
         }
@@ -558,7 +556,7 @@ public async Task SwallowsExceptionForMissingFeatureFilter()
 
             IFeatureManager featureManager = serviceProvider.GetRequiredService<IFeatureManager>();
 
-            var isEnabled = await featureManager.IsEnabledAsync(ConditionalFeature, CancellationToken.None);
+            var isEnabled = await featureManager.IsEnabledAsync(ConditionalFeature);
 
             Assert.False(isEnabled);
         }
@@ -636,7 +634,7 @@ public async Task CustomFeatureDefinitionProvider()
                 return Task.FromResult(true);
             };
 
-            await featureManager.IsEnabledAsync(ConditionalFeature, CancellationToken.None);
+            await featureManager.IsEnabledAsync(ConditionalFeature);
 
             Assert.True(called);
         }
diff --git a/tests/Tests.FeatureManagement/InMemoryFeatureDefinitionProvider.cs b/tests/Tests.FeatureManagement/InMemoryFeatureDefinitionProvider.cs
index 76d64a10..fe613254 100644
--- a/tests/Tests.FeatureManagement/InMemoryFeatureDefinitionProvider.cs
+++ b/tests/Tests.FeatureManagement/InMemoryFeatureDefinitionProvider.cs
@@ -2,8 +2,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Tests.FeatureManagement
@@ -18,7 +16,7 @@ public InMemoryFeatureDefinitionProvider(IEnumerable<FeatureDefinition> featureD
         }
 
 #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
-        public async IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync([EnumeratorCancellation] CancellationToken _)
+        public async IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync()
 #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
         {
             foreach (FeatureDefinition definition in _definitions)
@@ -27,7 +25,7 @@ public async IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync([
             }
         }
 
-        public Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName, CancellationToken _)
+        public Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName)
         {
             return Task.FromResult(_definitions.FirstOrDefault(definitions => definitions.Name.Equals(featureName, StringComparison.OrdinalIgnoreCase)));
         }
diff --git a/tests/Tests.FeatureManagement/InvalidFeatureFilter.cs b/tests/Tests.FeatureManagement/InvalidFeatureFilter.cs
index 4f81e3e2..0fab5063 100644
--- a/tests/Tests.FeatureManagement/InvalidFeatureFilter.cs
+++ b/tests/Tests.FeatureManagement/InvalidFeatureFilter.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 //
 using Microsoft.FeatureManagement;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Tests.FeatureManagement
@@ -11,12 +10,12 @@ namespace Tests.FeatureManagement
     // Cannot implement more than one IFeatureFilter interface
     class InvalidFeatureFilter : IContextualFeatureFilter<IAccountContext>, IContextualFeatureFilter<object>
     {
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, IAccountContext accountContext, CancellationToken _)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, IAccountContext accountContext)
         {
             return Task.FromResult(false);
         }
 
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, object appContext, CancellationToken _)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, object appContext)
         {
             return Task.FromResult(false);
         }
@@ -26,12 +25,12 @@ public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterCont
     // Cannot implement more than one IFeatureFilter interface
     class InvalidFeatureFilter2 : IFeatureFilter, IContextualFeatureFilter<object>
     {
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, object appContext, CancellationToken _)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, object appContext)
         {
             return Task.FromResult(false);
         }
 
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, CancellationToken _)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
             return Task.FromResult(false);
         }
diff --git a/tests/Tests.FeatureManagement/OnDemandTargetingContextAccessor.cs b/tests/Tests.FeatureManagement/OnDemandTargetingContextAccessor.cs
index aaff4a41..7eb7e971 100644
--- a/tests/Tests.FeatureManagement/OnDemandTargetingContextAccessor.cs
+++ b/tests/Tests.FeatureManagement/OnDemandTargetingContextAccessor.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 //
 using Microsoft.FeatureManagement.FeatureFilters;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Tests.FeatureManagement
@@ -11,7 +10,7 @@ class OnDemandTargetingContextAccessor : ITargetingContextAccessor
     {
         public TargetingContext Current { get; set; }
 
-        public ValueTask<TargetingContext> GetContextAsync(CancellationToken _)
+        public ValueTask<TargetingContext> GetContextAsync()
         {
             return new ValueTask<TargetingContext>(Current);
         }
diff --git a/tests/Tests.FeatureManagement/TestFilter.cs b/tests/Tests.FeatureManagement/TestFilter.cs
index b2de169d..2dbf0f71 100644
--- a/tests/Tests.FeatureManagement/TestFilter.cs
+++ b/tests/Tests.FeatureManagement/TestFilter.cs
@@ -4,7 +4,6 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.FeatureManagement;
 using System;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Tests.FeatureManagement
@@ -25,7 +24,7 @@ public object BindParameters(IConfiguration parameters)
             return parameters;
         }
 
-        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context, CancellationToken _)
+        public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
             return Callback?.Invoke(context) ?? Task.FromResult(false);
         }