feat!: add CancellationTokens, ValueTasks hooks (#268)

This PR is a combination of
#184 and
#185. Changes include:

- adding cancellation tokens
- in all cases where async operations include side-effects
(`setProviderAsync`, `InitializeAsync`, I've specified in the in-line
doc that the cancellation token's purpose is to cancel such side-effects
- so setting a provider and canceling that operation still results in
that provider's being set, but async side-effect should be cancelled.
I'm interested in feedback here, I think we need to consider the
semantics around this... I suppose the alternative would be to always
ensure any state changes only occur after async side-effects, if they
weren't cancelled beforehand.
- adding "Async" suffix to all async methods
- remove deprecated sync `SetProvider` methods 
- Using `ValueTask` for hook methods
- I've decided against converting all `Tasks` to `ValueTasks`, from the
[official .NET
docs](https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.valuetask?view=net-8.0):
> the default choice for any asynchronous method that does not return a
result should be to return a
[Task](https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task?view=net-8.0).
Only if performance analysis proves it worthwhile should a ValueTask be
used instead of a
[Task](https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task?view=net-8.0).
- I think for hooks, `ValueTask` especially makes sense since often
hooks are synchronous, in fact async hooks are probably the less likely
variant.
- I've kept the resolver methods as `Task`, but there could be an
argument for making them `ValueTask`, since some providers resolve
asynchronously.
- I'm still a bit dubious on the entire idea of `ValueTask`, so I'm
really interested in feedback here
- associated test updates

UPDATE:

After chewing on this for a night, I'm starting to feel:
- We should simply remove cancellation tokens from Init/Shutdown. We can
always add them later, which would be non-breaking. I think the value is
low and the complexity is potentially high.
- ValueTask is only a good idea for hooks, because:
  - Hooks will very often be synchronous under the hood
- We (SDK authors) await the hooks, not consumer code, so we can be
careful of the potential pitfalls of ValueTask. I think everywhere else
we should stick to Task.

---------

Signed-off-by: Austin Drenski <[email protected]>
Signed-off-by: Todd Baert <[email protected]>
Co-authored-by: Austin Drenski <[email protected]>
Co-authored-by: André Silva <[email protected]>
Co-authored-by: Ryan Lamb <[email protected]>

Author: 4 people

README.md

@@ -37,40 +37,17 @@ static Api() { }
         private Api() { }
 
         /// <summary>
-        /// Sets the default feature provider to given clientName without awaiting its initialization.
-        /// </summary>
-        /// <remarks>The provider cannot be set to null. Attempting to set the provider to null has no effect.</remarks>
-        /// <param name="featureProvider">Implementation of <see cref="FeatureProvider"/></param>
-        [Obsolete("Will be removed in later versions; use SetProviderAsync, which can be awaited")]
-        public void SetProvider(FeatureProvider featureProvider)
-        {
-            this._eventExecutor.RegisterDefaultFeatureProvider(featureProvider);
-            _ = this._repository.SetProvider(featureProvider, this.GetContext());
-        }
-
-        /// <summary>
-        /// Sets the default feature provider. In order to wait for the provider to be set, and initialization to complete,
+        /// Sets the feature provider. In order to wait for the provider to be set, and initialization to complete,
         /// await the returned task.
         /// </summary>
         /// <remarks>The provider cannot be set to null. Attempting to set the provider to null has no effect.</remarks>
         /// <param name="featureProvider">Implementation of <see cref="FeatureProvider"/></param>
-        public async Task SetProviderAsync(FeatureProvider? featureProvider)
+        public async Task SetProviderAsync(FeatureProvider featureProvider)
         {
             this._eventExecutor.RegisterDefaultFeatureProvider(featureProvider);
-            await this._repository.SetProvider(featureProvider, this.GetContext()).ConfigureAwait(false);
+            await this._repository.SetProviderAsync(featureProvider, this.GetContext()).ConfigureAwait(false);
         }
 
-        /// <summary>
-        /// Sets the feature provider to given clientName without awaiting its initialization.
-        /// </summary>
-        /// <param name="clientName">Name of client</param>
-        /// <param name="featureProvider">Implementation of <see cref="FeatureProvider"/></param>
-        [Obsolete("Will be removed in later versions; use SetProviderAsync, which can be awaited")]
-        public void SetProvider(string clientName, FeatureProvider featureProvider)
-        {
-            this._eventExecutor.RegisterClientFeatureProvider(clientName, featureProvider);
-            _ = this._repository.SetProvider(clientName, featureProvider, this.GetContext());
-        }
 
         /// <summary>
         /// Sets the feature provider to given clientName. In order to wait for the provider to be set, and
@@ -85,7 +62,7 @@ public async Task SetProviderAsync(string clientName, FeatureProvider featurePro
                 throw new ArgumentNullException(nameof(clientName));
             }
             this._eventExecutor.RegisterClientFeatureProvider(clientName, featureProvider);
-            await this._repository.SetProvider(clientName, featureProvider, this.GetContext()).ConfigureAwait(false);
+            await this._repository.SetProviderAsync(clientName, featureProvider, this.GetContext()).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -248,7 +225,7 @@ public EvaluationContext GetContext()
         /// Once shut down is complete, API is reset and ready to use again.
         /// </para>
         /// </summary>
-        public async Task Shutdown()
+        public async Task ShutdownAsync()
         {
             await using (this._eventExecutor.ConfigureAwait(false))
             await using (this._repository.ConfigureAwait(false))

src/OpenFeature/Api.cs

@@ -10,6 +10,8 @@
 
 namespace OpenFeature
 {
+    internal delegate Task ShutdownDelegate(CancellationToken cancellationToken);
+
     internal sealed partial class EventExecutor : IAsyncDisposable
     {
         private readonly object _lockObj = new object();
@@ -30,7 +32,7 @@ public EventExecutor()
             eventProcessing.Start();
         }
 
-        public ValueTask DisposeAsync() => new(this.Shutdown());
+        public ValueTask DisposeAsync() => new(this.ShutdownAsync());
 
         internal void SetLogger(ILogger logger) => this._logger = logger;
 
@@ -317,10 +319,9 @@ private void InvokeEventHandler(EventHandlerDelegate eventHandler, Event e)
             }
         }
 
-        public async Task Shutdown()
+        public async Task ShutdownAsync()
         {
             this.EventChannel.Writer.Complete();
-
             await this.EventChannel.Reader.Completion.ConfigureAwait(false);
         }
 

src/OpenFeature/EventExecutor.cs

@@ -1,4 +1,5 @@
 using System.Collections.Immutable;
+using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;
 using OpenFeature.Constant;
@@ -43,49 +44,54 @@ public abstract class FeatureProvider
         /// <param name="flagKey">Feature flag key</param>
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext"/></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns><see cref="ResolutionDetails{T}"/></returns>
-        public abstract Task<ResolutionDetails<bool>> ResolveBooleanValue(string flagKey, bool defaultValue,
-            EvaluationContext? context = null);
+        public abstract Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(string flagKey, bool defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a string feature flag
         /// </summary>
         /// <param name="flagKey">Feature flag key</param>
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext"/></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns><see cref="ResolutionDetails{T}"/></returns>
-        public abstract Task<ResolutionDetails<string>> ResolveStringValue(string flagKey, string defaultValue,
-            EvaluationContext? context = null);
+        public abstract Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey, string defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a integer feature flag
         /// </summary>
         /// <param name="flagKey">Feature flag key</param>
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext"/></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns><see cref="ResolutionDetails{T}"/></returns>
-        public abstract Task<ResolutionDetails<int>> ResolveIntegerValue(string flagKey, int defaultValue,
-            EvaluationContext? context = null);
+        public abstract Task<ResolutionDetails<int>> ResolveIntegerValueAsync(string flagKey, int defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a double feature flag
         /// </summary>
         /// <param name="flagKey">Feature flag key</param>
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext"/></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns><see cref="ResolutionDetails{T}"/></returns>
-        public abstract Task<ResolutionDetails<double>> ResolveDoubleValue(string flagKey, double defaultValue,
-            EvaluationContext? context = null);
+        public abstract Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey, double defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a structured feature flag
         /// </summary>
         /// <param name="flagKey">Feature flag key</param>
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext"/></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns><see cref="ResolutionDetails{T}"/></returns>
-        public abstract Task<ResolutionDetails<Value>> ResolveStructureValue(string flagKey, Value defaultValue,
-            EvaluationContext? context = null);
+        public abstract Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey, Value defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Get the status of the provider.
@@ -95,7 +101,7 @@ public abstract Task<ResolutionDetails<Value>> ResolveStructureValue(string flag
         /// If a provider does not override this method, then its status will be assumed to be
         /// <see cref="ProviderStatus.Ready"/>. If a provider implements this method, and supports initialization,
         /// then it should start in the <see cref="ProviderStatus.NotReady"/>status . If the status is
-        /// <see cref="ProviderStatus.NotReady"/>, then the Api will call the <see cref="Initialize" /> when the
+        /// <see cref="ProviderStatus.NotReady"/>, then the Api will call the <see cref="InitializeAsync" /> when the
         /// provider is set.
         /// </remarks>
         public virtual ProviderStatus GetStatus() => ProviderStatus.Ready;
@@ -107,6 +113,7 @@ public abstract Task<ResolutionDetails<Value>> ResolveStructureValue(string flag
         /// </para>
         /// </summary>
         /// <param name="context"><see cref="EvaluationContext"/></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to cancel any async side effects.</param>
         /// <returns>A task that completes when the initialization process is complete.</returns>
         /// <remarks>
         /// <para>
@@ -118,7 +125,7 @@ public abstract Task<ResolutionDetails<Value>> ResolveStructureValue(string flag
         /// the <see cref="GetStatus"/> method after initialization is complete.
         /// </para>
         /// </remarks>
-        public virtual Task Initialize(EvaluationContext context)
+        public virtual Task InitializeAsync(EvaluationContext context, CancellationToken cancellationToken = default)
         {
             // Intentionally left blank.
             return Task.CompletedTask;
@@ -129,7 +136,8 @@ public virtual Task Initialize(EvaluationContext context)
         /// Providers can overwrite this method, if they have special shutdown actions needed.
         /// </summary>
         /// <returns>A task that completes when the shutdown process is complete.</returns>
-        public virtual Task Shutdown()
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to cancel any async side effects.</param>
+        public virtual Task ShutdownAsync(CancellationToken cancellationToken = default)
         {
             // Intentionally left blank.
             return Task.CompletedTask;

src/OpenFeature/FeatureProvider.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using OpenFeature.Model;
 
@@ -26,12 +27,13 @@ public abstract class Hook
         /// </summary>
         /// <param name="context">Provides context of innovation</param>
         /// <param name="hints">Caller provided data</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <typeparam name="T">Flag value type (bool|number|string|object)</typeparam>
         /// <returns>Modified EvaluationContext that is used for the flag evaluation</returns>
-        public virtual Task<EvaluationContext> Before<T>(HookContext<T> context,
-            IReadOnlyDictionary<string, object>? hints = null)
+        public virtual ValueTask<EvaluationContext> BeforeAsync<T>(HookContext<T> context,
+            IReadOnlyDictionary<string, object>? hints = null, CancellationToken cancellationToken = default)
         {
-            return Task.FromResult(EvaluationContext.Empty);
+            return new ValueTask<EvaluationContext>(EvaluationContext.Empty);
         }
 
         /// <summary>
@@ -40,11 +42,12 @@ public virtual Task<EvaluationContext> Before<T>(HookContext<T> context,
         /// <param name="context">Provides context of innovation</param>
         /// <param name="details">Flag evaluation information</param>
         /// <param name="hints">Caller provided data</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <typeparam name="T">Flag value type (bool|number|string|object)</typeparam>
-        public virtual Task After<T>(HookContext<T> context, FlagEvaluationDetails<T> details,
-            IReadOnlyDictionary<string, object>? hints = null)
+        public virtual ValueTask AfterAsync<T>(HookContext<T> context, FlagEvaluationDetails<T> details,
+            IReadOnlyDictionary<string, object>? hints = null, CancellationToken cancellationToken = default)
         {
-            return Task.CompletedTask;
+            return new ValueTask();
         }
 
         /// <summary>
@@ -53,22 +56,24 @@ public virtual Task After<T>(HookContext<T> context, FlagEvaluationDetails<T> de
         /// <param name="context">Provides context of innovation</param>
         /// <param name="error">Exception representing what went wrong</param>
         /// <param name="hints">Caller provided data</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <typeparam name="T">Flag value type (bool|number|string|object)</typeparam>
-        public virtual Task Error<T>(HookContext<T> context, Exception error,
-            IReadOnlyDictionary<string, object>? hints = null)
+        public virtual ValueTask ErrorAsync<T>(HookContext<T> context, Exception error,
+            IReadOnlyDictionary<string, object>? hints = null, CancellationToken cancellationToken = default)
         {
-            return Task.CompletedTask;
+            return new ValueTask();
         }
 
         /// <summary>
         /// Called unconditionally after flag evaluation.
         /// </summary>
         /// <param name="context">Provides context of innovation</param>
         /// <param name="hints">Caller provided data</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <typeparam name="T">Flag value type (bool|number|string|object)</typeparam>
-        public virtual Task Finally<T>(HookContext<T> context, IReadOnlyDictionary<string, object>? hints = null)
+        public virtual ValueTask FinallyAsync<T>(HookContext<T> context, IReadOnlyDictionary<string, object>? hints = null, CancellationToken cancellationToken = default)
         {
-            return Task.CompletedTask;
+            return new ValueTask();
         }
     }
 }

src/OpenFeature/Hook.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using OpenFeature.Model;
 
@@ -59,8 +60,9 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag value.</returns>
-        Task<bool> GetBooleanValue(string flagKey, bool defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<bool> GetBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a boolean feature flag
@@ -69,8 +71,9 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
-        Task<FlagEvaluationDetails<bool>> GetBooleanDetails(string flagKey, bool defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<FlagEvaluationDetails<bool>> GetBooleanDetailsAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a string feature flag
@@ -79,8 +82,9 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag value.</returns>
-        Task<string> GetStringValue(string flagKey, string defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<string> GetStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a string feature flag
@@ -89,8 +93,9 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
-        Task<FlagEvaluationDetails<string>> GetStringDetails(string flagKey, string defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<FlagEvaluationDetails<string>> GetStringDetailsAsync(string flagKey, string defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a integer feature flag
@@ -99,8 +104,9 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag value.</returns>
-        Task<int> GetIntegerValue(string flagKey, int defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<int> GetIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a integer feature flag
@@ -109,8 +115,9 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
-        Task<FlagEvaluationDetails<int>> GetIntegerDetails(string flagKey, int defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<FlagEvaluationDetails<int>> GetIntegerDetailsAsync(string flagKey, int defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a double feature flag
@@ -119,8 +126,9 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag value.</returns>
-        Task<double> GetDoubleValue(string flagKey, double defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<double> GetDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a double feature flag
@@ -129,8 +137,9 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
-        Task<FlagEvaluationDetails<double>> GetDoubleDetails(string flagKey, double defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<FlagEvaluationDetails<double>> GetDoubleDetailsAsync(string flagKey, double defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a structure object feature flag
@@ -139,8 +148,9 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag value.</returns>
-        Task<Value> GetObjectValue(string flagKey, Value defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<Value> GetObjectValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Resolves a structure object feature flag
@@ -149,7 +159,8 @@ public interface IFeatureClient : IEventBus
         /// <param name="defaultValue">Default value</param>
         /// <param name="context"><see cref="EvaluationContext">Evaluation Context</see></param>
         /// <param name="config"><see cref="EvaluationContext">Flag Evaluation Options</see></param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
-        Task<FlagEvaluationDetails<Value>> GetObjectDetails(string flagKey, Value defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null);
+        Task<FlagEvaluationDetails<Value>> GetObjectDetailsAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, FlagEvaluationOptions? config = null, CancellationToken cancellationToken = default);
     }
 }

src/OpenFeature/IFeatureClient.cs

@@ -1,3 +1,4 @@
+using System.Threading;
 using System.Threading.Tasks;
 using OpenFeature.Constant;
 using OpenFeature.Model;
@@ -13,27 +14,27 @@ public override Metadata GetMetadata()
             return this._metadata;
         }
 
-        public override Task<ResolutionDetails<bool>> ResolveBooleanValue(string flagKey, bool defaultValue, EvaluationContext? context = null)
+        public override Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(NoOpResponse(flagKey, defaultValue));
         }
 
-        public override Task<ResolutionDetails<string>> ResolveStringValue(string flagKey, string defaultValue, EvaluationContext? context = null)
+        public override Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(NoOpResponse(flagKey, defaultValue));
         }
 
-        public override Task<ResolutionDetails<int>> ResolveIntegerValue(string flagKey, int defaultValue, EvaluationContext? context = null)
+        public override Task<ResolutionDetails<int>> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(NoOpResponse(flagKey, defaultValue));
         }
 
-        public override Task<ResolutionDetails<double>> ResolveDoubleValue(string flagKey, double defaultValue, EvaluationContext? context = null)
+        public override Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(NoOpResponse(flagKey, defaultValue));
         }
 
-        public override Task<ResolutionDetails<Value>> ResolveStructureValue(string flagKey, Value defaultValue, EvaluationContext? context = null)
+        public override Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(NoOpResponse(flagKey, defaultValue));
         }

src/OpenFeature/NoOpProvider.cs

@@ -35,7 +35,7 @@ public async ValueTask DisposeAsync()
         {
             using (this._providersLock)
             {
-                await this.Shutdown().ConfigureAwait(false);
+                await this.ShutdownAsync().ConfigureAwait(false);
             }
         }
 
@@ -62,7 +62,7 @@ public async ValueTask DisposeAsync()
         /// initialization
         /// </param>
         /// <param name="afterShutdown">called after a provider is shutdown, can be used to remove event handlers</param>
-        public async Task SetProvider(
+        public async Task SetProviderAsync(
             FeatureProvider? featureProvider,
             EvaluationContext context,
             Action<FeatureProvider>? afterSet = null,
@@ -92,19 +92,19 @@ public async Task SetProvider(
                 // We want to allow shutdown to happen concurrently with initialization, and the caller to not
                 // wait for it.
 #pragma warning disable CS4014
-                this.ShutdownIfUnused(oldProvider, afterShutdown, afterError);
+                this.ShutdownIfUnusedAsync(oldProvider, afterShutdown, afterError);
 #pragma warning restore CS4014
             }
             finally
             {
                 this._providersLock.ExitWriteLock();
             }
 
-            await InitProvider(this._defaultProvider, context, afterInitialization, afterError)
+            await InitProviderAsync(this._defaultProvider, context, afterInitialization, afterError)
                 .ConfigureAwait(false);
         }
 
-        private static async Task InitProvider(
+        private static async Task InitProviderAsync(
             FeatureProvider? newProvider,
             EvaluationContext context,
             Action<FeatureProvider>? afterInitialization,
@@ -118,7 +118,7 @@ private static async Task InitProvider(
             {
                 try
                 {
-                    await newProvider.Initialize(context).ConfigureAwait(false);
+                    await newProvider.InitializeAsync(context).ConfigureAwait(false);
                     afterInitialization?.Invoke(newProvider);
                 }
                 catch (Exception ex)
@@ -152,13 +152,15 @@ private static async Task InitProvider(
         /// initialization
         /// </param>
         /// <param name="afterShutdown">called after a provider is shutdown, can be used to remove event handlers</param>
-        public async Task SetProvider(string? clientName,
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to cancel any async side effects.</param>
+        public async Task SetProviderAsync(string clientName,
             FeatureProvider? featureProvider,
             EvaluationContext context,
             Action<FeatureProvider>? afterSet = null,
             Action<FeatureProvider>? afterInitialization = null,
             Action<FeatureProvider, Exception>? afterError = null,
-            Action<FeatureProvider>? afterShutdown = null)
+            Action<FeatureProvider>? afterShutdown = null,
+            CancellationToken cancellationToken = default)
         {
             // Cannot set a provider for a null clientName.
             if (clientName == null)
@@ -187,21 +189,21 @@ public async Task SetProvider(string? clientName,
                 // We want to allow shutdown to happen concurrently with initialization, and the caller to not
                 // wait for it.
 #pragma warning disable CS4014
-                this.ShutdownIfUnused(oldProvider, afterShutdown, afterError);
+                this.ShutdownIfUnusedAsync(oldProvider, afterShutdown, afterError);
 #pragma warning restore CS4014
             }
             finally
             {
                 this._providersLock.ExitWriteLock();
             }
 
-            await InitProvider(featureProvider, context, afterInitialization, afterError).ConfigureAwait(false);
+            await InitProviderAsync(featureProvider, context, afterInitialization, afterError).ConfigureAwait(false);
         }
 
         /// <remarks>
         /// Shutdown the feature provider if it is unused. This must be called within a write lock of the _providersLock.
         /// </remarks>
-        private async Task ShutdownIfUnused(
+        private async Task ShutdownIfUnusedAsync(
             FeatureProvider? targetProvider,
             Action<FeatureProvider>? afterShutdown,
             Action<FeatureProvider, Exception>? afterError)
@@ -216,7 +218,7 @@ private async Task ShutdownIfUnused(
                 return;
             }
 
-            await SafeShutdownProvider(targetProvider, afterShutdown, afterError).ConfigureAwait(false);
+            await SafeShutdownProviderAsync(targetProvider, afterShutdown, afterError).ConfigureAwait(false);
         }
 
         /// <remarks>
@@ -228,7 +230,7 @@ private async Task ShutdownIfUnused(
         /// it would not be meaningful to emit an error.
         /// </para>
         /// </remarks>
-        private static async Task SafeShutdownProvider(FeatureProvider? targetProvider,
+        private static async Task SafeShutdownProviderAsync(FeatureProvider? targetProvider,
             Action<FeatureProvider>? afterShutdown,
             Action<FeatureProvider, Exception>? afterError)
         {
@@ -239,7 +241,7 @@ private static async Task SafeShutdownProvider(FeatureProvider? targetProvider,
 
             try
             {
-                await targetProvider.Shutdown().ConfigureAwait(false);
+                await targetProvider.ShutdownAsync().ConfigureAwait(false);
                 afterShutdown?.Invoke(targetProvider);
             }
             catch (Exception ex)
@@ -281,7 +283,7 @@ public FeatureProvider GetProvider(string? clientName)
                 : this.GetProvider();
         }
 
-        public async Task Shutdown(Action<FeatureProvider, Exception>? afterError = null)
+        public async Task ShutdownAsync(Action<FeatureProvider, Exception>? afterError = null, CancellationToken cancellationToken = default)
         {
             var providers = new HashSet<FeatureProvider>();
             this._providersLock.EnterWriteLock();
@@ -305,7 +307,7 @@ public async Task Shutdown(Action<FeatureProvider, Exception>? afterError = null
             foreach (var targetProvider in providers)
             {
                 // We don't need to take any actions after shutdown.
-                await SafeShutdownProvider(targetProvider, null, afterError).ConfigureAwait(false);
+                await SafeShutdownProviderAsync(targetProvider, null, afterError).ConfigureAwait(false);
             }
         }
     }

src/OpenFeature/OpenFeatureClient.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using OpenFeature.Constant;
 using OpenFeature.Error;
@@ -45,7 +46,7 @@ public InMemoryProvider(IDictionary<string, Flag>? flags = null)
         /// Updating provider flags configuration, replacing all flags.
         /// </summary>
         /// <param name="flags">the flags to use instead of the previous flags.</param>
-        public async ValueTask UpdateFlags(IDictionary<string, Flag>? flags = null)
+        public async Task UpdateFlags(IDictionary<string, Flag>? flags = null)
         {
             var changed = this._flags.Keys.ToList();
             if (flags == null)
@@ -68,46 +69,31 @@ public async ValueTask UpdateFlags(IDictionary<string, Flag>? flags = null)
         }
 
         /// <inheritdoc/>
-        public override Task<ResolutionDetails<bool>> ResolveBooleanValue(
-            string flagKey,
-            bool defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(Resolve(flagKey, defaultValue, context));
         }
 
         /// <inheritdoc/>
-        public override Task<ResolutionDetails<string>> ResolveStringValue(
-            string flagKey,
-            string defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(Resolve(flagKey, defaultValue, context));
         }
 
         /// <inheritdoc/>
-        public override Task<ResolutionDetails<int>> ResolveIntegerValue(
-            string flagKey,
-            int defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<int>> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(Resolve(flagKey, defaultValue, context));
         }
 
         /// <inheritdoc/>
-        public override Task<ResolutionDetails<double>> ResolveDoubleValue(
-            string flagKey,
-            double defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(Resolve(flagKey, defaultValue, context));
         }
 
         /// <inheritdoc/>
-        public override Task<ResolutionDetails<Value>> ResolveStructureValue(
-            string flagKey,
-            Value defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(Resolve(flagKey, defaultValue, context));
         }

src/OpenFeature/ProviderRepository.cs

@@ -45,62 +45,62 @@ public OpenFeatureClientBenchmarks()
 
         [Benchmark]
         public async Task OpenFeatureClient_GetBooleanValue_WithoutEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetBooleanValue(_flagName, _defaultBoolValue);
+            await _client.GetBooleanValueAsync(_flagName, _defaultBoolValue);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetBooleanValue_WithEmptyEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetBooleanValue(_flagName, _defaultBoolValue, EvaluationContext.Empty);
+            await _client.GetBooleanValueAsync(_flagName, _defaultBoolValue, EvaluationContext.Empty);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetBooleanValue_WithEmptyEvaluationContext_WithEmptyFlagEvaluationOptions() =>
-            await _client.GetBooleanValue(_flagName, _defaultBoolValue, EvaluationContext.Empty, _emptyFlagOptions);
+            await _client.GetBooleanValueAsync(_flagName, _defaultBoolValue, EvaluationContext.Empty, _emptyFlagOptions);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetStringValue_WithoutEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetStringValue(_flagName, _defaultStringValue);
+            await _client.GetStringValueAsync(_flagName, _defaultStringValue);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetStringValue_WithEmptyEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetStringValue(_flagName, _defaultStringValue, EvaluationContext.Empty);
+            await _client.GetStringValueAsync(_flagName, _defaultStringValue, EvaluationContext.Empty);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetStringValue_WithoutEvaluationContext_WithEmptyFlagEvaluationOptions() =>
-            await _client.GetStringValue(_flagName, _defaultStringValue, EvaluationContext.Empty, _emptyFlagOptions);
+            await _client.GetStringValueAsync(_flagName, _defaultStringValue, EvaluationContext.Empty, _emptyFlagOptions);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetIntegerValue_WithoutEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetIntegerValue(_flagName, _defaultIntegerValue);
+            await _client.GetIntegerValueAsync(_flagName, _defaultIntegerValue);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetIntegerValue_WithEmptyEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetIntegerValue(_flagName, _defaultIntegerValue, EvaluationContext.Empty);
+            await _client.GetIntegerValueAsync(_flagName, _defaultIntegerValue, EvaluationContext.Empty);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetIntegerValue_WithEmptyEvaluationContext_WithEmptyFlagEvaluationOptions() =>
-            await _client.GetIntegerValue(_flagName, _defaultIntegerValue, EvaluationContext.Empty, _emptyFlagOptions);
+            await _client.GetIntegerValueAsync(_flagName, _defaultIntegerValue, EvaluationContext.Empty, _emptyFlagOptions);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetDoubleValue_WithoutEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetDoubleValue(_flagName, _defaultDoubleValue);
+            await _client.GetDoubleValueAsync(_flagName, _defaultDoubleValue);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetDoubleValue_WithEmptyEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetDoubleValue(_flagName, _defaultDoubleValue, EvaluationContext.Empty);
+            await _client.GetDoubleValueAsync(_flagName, _defaultDoubleValue, EvaluationContext.Empty);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetDoubleValue_WithEmptyEvaluationContext_WithEmptyFlagEvaluationOptions() =>
-            await _client.GetDoubleValue(_flagName, _defaultDoubleValue, EvaluationContext.Empty, _emptyFlagOptions);
+            await _client.GetDoubleValueAsync(_flagName, _defaultDoubleValue, EvaluationContext.Empty, _emptyFlagOptions);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetObjectValue_WithoutEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetObjectValue(_flagName, _defaultStructureValue);
+            await _client.GetObjectValueAsync(_flagName, _defaultStructureValue);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetObjectValue_WithEmptyEvaluationContext_WithoutFlagEvaluationOptions() =>
-            await _client.GetObjectValue(_flagName, _defaultStructureValue, EvaluationContext.Empty);
+            await _client.GetObjectValueAsync(_flagName, _defaultStructureValue, EvaluationContext.Empty);
 
         [Benchmark]
         public async Task OpenFeatureClient_GetObjectValue_WithEmptyEvaluationContext_WithEmptyFlagEvaluationOptions() =>
-            await _client.GetObjectValue(_flagName, _defaultStructureValue, EvaluationContext.Empty, _emptyFlagOptions);
+            await _client.GetObjectValueAsync(_flagName, _defaultStructureValue, EvaluationContext.Empty, _emptyFlagOptions);
     }
 }

src/OpenFeature/Providers/Memory/InMemoryProvider.cs

@@ -49,7 +49,7 @@ public void GivenAProviderIsRegistered()
         [When(@"a boolean flag with key ""(.*)"" is evaluated with default value ""(.*)""")]
         public void Whenabooleanflagwithkeyisevaluatedwithdefaultvalue(string flagKey, bool defaultValue)
         {
-            this.booleanFlagValue = client?.GetBooleanValue(flagKey, defaultValue);
+            this.booleanFlagValue = client?.GetBooleanValueAsync(flagKey, defaultValue);
         }
 
         [Then(@"the resolved boolean value should be ""(.*)""")]
@@ -61,7 +61,7 @@ public void Thentheresolvedbooleanvalueshouldbe(bool expectedValue)
         [When(@"a string flag with key ""(.*)"" is evaluated with default value ""(.*)""")]
         public void Whenastringflagwithkeyisevaluatedwithdefaultvalue(string flagKey, string defaultValue)
         {
-            this.stringFlagValue = client?.GetStringValue(flagKey, defaultValue);
+            this.stringFlagValue = client?.GetStringValueAsync(flagKey, defaultValue);
         }
 
         [Then(@"the resolved string value should be ""(.*)""")]
@@ -73,7 +73,7 @@ public void Thentheresolvedstringvalueshouldbe(string expected)
         [When(@"an integer flag with key ""(.*)"" is evaluated with default value (.*)")]
         public void Whenanintegerflagwithkeyisevaluatedwithdefaultvalue(string flagKey, int defaultValue)
         {
-            this.intFlagValue = client?.GetIntegerValue(flagKey, defaultValue);
+            this.intFlagValue = client?.GetIntegerValueAsync(flagKey, defaultValue);
         }
 
         [Then(@"the resolved integer value should be (.*)")]
@@ -85,7 +85,7 @@ public void Thentheresolvedintegervalueshouldbe(int expected)
         [When(@"a float flag with key ""(.*)"" is evaluated with default value (.*)")]
         public void Whenafloatflagwithkeyisevaluatedwithdefaultvalue(string flagKey, double defaultValue)
         {
-            this.doubleFlagValue = client?.GetDoubleValue(flagKey, defaultValue);
+            this.doubleFlagValue = client?.GetDoubleValueAsync(flagKey, defaultValue);
         }
 
         [Then(@"the resolved float value should be (.*)")]
@@ -97,7 +97,7 @@ public void Thentheresolvedfloatvalueshouldbe(double expected)
         [When(@"an object flag with key ""(.*)"" is evaluated with a null default value")]
         public void Whenanobjectflagwithkeyisevaluatedwithanulldefaultvalue(string flagKey)
         {
-            this.objectFlagValue = client?.GetObjectValue(flagKey, new Value());
+            this.objectFlagValue = client?.GetObjectValueAsync(flagKey, new Value());
         }
 
         [Then(@"the resolved object value should be contain fields ""(.*)"", ""(.*)"", and ""(.*)"", with values ""(.*)"", ""(.*)"" and (.*), respectively")]
@@ -112,7 +112,7 @@ public void Thentheresolvedobjectvalueshouldbecontainfieldsandwithvaluesandrespe
         [When(@"a boolean flag with key ""(.*)"" is evaluated with details and default value ""(.*)""")]
         public void Whenabooleanflagwithkeyisevaluatedwithdetailsanddefaultvalue(string flagKey, bool defaultValue)
         {
-            this.booleanFlagDetails = client?.GetBooleanDetails(flagKey, defaultValue);
+            this.booleanFlagDetails = client?.GetBooleanDetailsAsync(flagKey, defaultValue);
         }
 
         [Then(@"the resolved boolean details value should be ""(.*)"", the variant should be ""(.*)"", and the reason should be ""(.*)""")]
@@ -127,7 +127,7 @@ public void Thentheresolvedbooleandetailsvalueshouldbethevariantshouldbeandthere
         [When(@"a string flag with key ""(.*)"" is evaluated with details and default value ""(.*)""")]
         public void Whenastringflagwithkeyisevaluatedwithdetailsanddefaultvalue(string flagKey, string defaultValue)
         {
-            this.stringFlagDetails = client?.GetStringDetails(flagKey, defaultValue);
+            this.stringFlagDetails = client?.GetStringDetailsAsync(flagKey, defaultValue);
         }
 
         [Then(@"the resolved string details value should be ""(.*)"", the variant should be ""(.*)"", and the reason should be ""(.*)""")]
@@ -142,7 +142,7 @@ public void Thentheresolvedstringdetailsvalueshouldbethevariantshouldbeandtherea
         [When(@"an integer flag with key ""(.*)"" is evaluated with details and default value (.*)")]
         public void Whenanintegerflagwithkeyisevaluatedwithdetailsanddefaultvalue(string flagKey, int defaultValue)
         {
-            this.intFlagDetails = client?.GetIntegerDetails(flagKey, defaultValue);
+            this.intFlagDetails = client?.GetIntegerDetailsAsync(flagKey, defaultValue);
         }
 
         [Then(@"the resolved integer details value should be (.*), the variant should be ""(.*)"", and the reason should be ""(.*)""")]
@@ -157,7 +157,7 @@ public void Thentheresolvedintegerdetailsvalueshouldbethevariantshouldbeandthere
         [When(@"a float flag with key ""(.*)"" is evaluated with details and default value (.*)")]
         public void Whenafloatflagwithkeyisevaluatedwithdetailsanddefaultvalue(string flagKey, double defaultValue)
         {
-            this.doubleFlagDetails = client?.GetDoubleDetails(flagKey, defaultValue);
+            this.doubleFlagDetails = client?.GetDoubleDetailsAsync(flagKey, defaultValue);
         }
 
         [Then(@"the resolved float details value should be (.*), the variant should be ""(.*)"", and the reason should be ""(.*)""")]
@@ -172,7 +172,7 @@ public void Thentheresolvedfloatdetailsvalueshouldbethevariantshouldbeandthereas
         [When(@"an object flag with key ""(.*)"" is evaluated with details and a null default value")]
         public void Whenanobjectflagwithkeyisevaluatedwithdetailsandanulldefaultvalue(string flagKey)
         {
-            this.objectFlagDetails = client?.GetObjectDetails(flagKey, new Value());
+            this.objectFlagDetails = client?.GetObjectDetailsAsync(flagKey, new Value());
         }
 
         [Then(@"the resolved object details value should be contain fields ""(.*)"", ""(.*)"", and ""(.*)"", with values ""(.*)"", ""(.*)"" and (.*), respectively")]
@@ -206,7 +206,7 @@ public void Givenaflagwithkeyisevaluatedwithdefaultvalue(string flagKey, string
         {
             contextAwareFlagKey = flagKey;
             contextAwareDefaultValue = defaultValue;
-            contextAwareValue = client?.GetStringValue(flagKey, contextAwareDefaultValue, context)?.Result;
+            contextAwareValue = client?.GetStringValueAsync(flagKey, contextAwareDefaultValue, context)?.Result;
         }
 
         [Then(@"the resolved string response should be ""(.*)""")]
@@ -218,7 +218,7 @@ public void Thentheresolvedstringresponseshouldbe(string expected)
         [Then(@"the resolved flag value is ""(.*)"" when the context is empty")]
         public void Giventheresolvedflagvalueiswhenthecontextisempty(string expected)
         {
-            string? emptyContextValue = client?.GetStringValue(contextAwareFlagKey!, contextAwareDefaultValue!, new EvaluationContextBuilder().Build()).Result;
+            string? emptyContextValue = client?.GetStringValueAsync(contextAwareFlagKey!, contextAwareDefaultValue!, EvaluationContext.Empty).Result;
             Assert.Equal(expected, emptyContextValue);
         }
 
@@ -227,7 +227,7 @@ public void Whenanonexistentstringflagwithkeyisevaluatedwithdetailsandadefaultva
         {
             this.notFoundFlagKey = flagKey;
             this.notFoundDefaultValue = defaultValue;
-            this.notFoundDetails = client?.GetStringDetails(this.notFoundFlagKey, this.notFoundDefaultValue).Result;
+            this.notFoundDetails = client?.GetStringDetailsAsync(this.notFoundFlagKey, this.notFoundDefaultValue).Result;
         }
 
         [Then(@"the default string value should be returned")]
@@ -248,7 +248,7 @@ public void Whenastringflagwithkeyisevaluatedasanintegerwithdetailsandadefaultva
         {
             this.typeErrorFlagKey = flagKey;
             this.typeErrorDefaultValue = defaultValue;
-            this.typeErrorDetails = client?.GetIntegerDetails(this.typeErrorFlagKey, this.typeErrorDefaultValue).Result;
+            this.typeErrorDetails = client?.GetIntegerDetailsAsync(this.typeErrorFlagKey, this.typeErrorDefaultValue).Result;
         }
 
         [Then(@"the default integer value should be returned")]

test/OpenFeature.Benchmarks/OpenFeatureClientBenchmarks.cs

@@ -44,27 +44,27 @@ public async Task Provider_Must_Resolve_Flag_Values()
 
             var boolResolutionDetails = new ResolutionDetails<bool>(flagName, defaultBoolValue, ErrorType.None,
                 NoOpProvider.ReasonNoOp, NoOpProvider.Variant);
-            (await provider.ResolveBooleanValue(flagName, defaultBoolValue)).Should()
+            (await provider.ResolveBooleanValueAsync(flagName, defaultBoolValue)).Should()
                 .BeEquivalentTo(boolResolutionDetails);
 
             var integerResolutionDetails = new ResolutionDetails<int>(flagName, defaultIntegerValue, ErrorType.None,
                 NoOpProvider.ReasonNoOp, NoOpProvider.Variant);
-            (await provider.ResolveIntegerValue(flagName, defaultIntegerValue)).Should()
+            (await provider.ResolveIntegerValueAsync(flagName, defaultIntegerValue)).Should()
                 .BeEquivalentTo(integerResolutionDetails);
 
             var doubleResolutionDetails = new ResolutionDetails<double>(flagName, defaultDoubleValue, ErrorType.None,
                 NoOpProvider.ReasonNoOp, NoOpProvider.Variant);
-            (await provider.ResolveDoubleValue(flagName, defaultDoubleValue)).Should()
+            (await provider.ResolveDoubleValueAsync(flagName, defaultDoubleValue)).Should()
                 .BeEquivalentTo(doubleResolutionDetails);
 
             var stringResolutionDetails = new ResolutionDetails<string>(flagName, defaultStringValue, ErrorType.None,
                 NoOpProvider.ReasonNoOp, NoOpProvider.Variant);
-            (await provider.ResolveStringValue(flagName, defaultStringValue)).Should()
+            (await provider.ResolveStringValueAsync(flagName, defaultStringValue)).Should()
                 .BeEquivalentTo(stringResolutionDetails);
 
             var structureResolutionDetails = new ResolutionDetails<Value>(flagName, defaultStructureValue,
                 ErrorType.None, NoOpProvider.ReasonNoOp, NoOpProvider.Variant);
-            (await provider.ResolveStructureValue(flagName, defaultStructureValue)).Should()
+            (await provider.ResolveStructureValueAsync(flagName, defaultStructureValue)).Should()
                 .BeEquivalentTo(structureResolutionDetails);
         }
 
@@ -84,59 +84,59 @@ public async Task Provider_Must_ErrorType()
             var providerMock = Substitute.For<FeatureProvider>();
             const string testMessage = "An error message";
 
-            providerMock.ResolveBooleanValue(flagName, defaultBoolValue, Arg.Any<EvaluationContext>())
+            providerMock.ResolveBooleanValueAsync(flagName, defaultBoolValue, Arg.Any<EvaluationContext>())
                 .Returns(new ResolutionDetails<bool>(flagName, defaultBoolValue, ErrorType.General,
                     NoOpProvider.ReasonNoOp, NoOpProvider.Variant, testMessage));
 
-            providerMock.ResolveIntegerValue(flagName, defaultIntegerValue, Arg.Any<EvaluationContext>())
+            providerMock.ResolveIntegerValueAsync(flagName, defaultIntegerValue, Arg.Any<EvaluationContext>())
                 .Returns(new ResolutionDetails<int>(flagName, defaultIntegerValue, ErrorType.ParseError,
                     NoOpProvider.ReasonNoOp, NoOpProvider.Variant, testMessage));
 
-            providerMock.ResolveDoubleValue(flagName, defaultDoubleValue, Arg.Any<EvaluationContext>())
+            providerMock.ResolveDoubleValueAsync(flagName, defaultDoubleValue, Arg.Any<EvaluationContext>())
                 .Returns(new ResolutionDetails<double>(flagName, defaultDoubleValue, ErrorType.InvalidContext,
                     NoOpProvider.ReasonNoOp, NoOpProvider.Variant, testMessage));
 
-            providerMock.ResolveStringValue(flagName, defaultStringValue, Arg.Any<EvaluationContext>())
+            providerMock.ResolveStringValueAsync(flagName, defaultStringValue, Arg.Any<EvaluationContext>())
                 .Returns(new ResolutionDetails<string>(flagName, defaultStringValue, ErrorType.TypeMismatch,
                     NoOpProvider.ReasonNoOp, NoOpProvider.Variant, testMessage));
 
-            providerMock.ResolveStructureValue(flagName, defaultStructureValue, Arg.Any<EvaluationContext>())
+            providerMock.ResolveStructureValueAsync(flagName, defaultStructureValue, Arg.Any<EvaluationContext>())
                 .Returns(new ResolutionDetails<Value>(flagName, defaultStructureValue, ErrorType.FlagNotFound,
                     NoOpProvider.ReasonNoOp, NoOpProvider.Variant, testMessage));
 
-            providerMock.ResolveStructureValue(flagName2, defaultStructureValue, Arg.Any<EvaluationContext>())
+            providerMock.ResolveStructureValueAsync(flagName2, defaultStructureValue, Arg.Any<EvaluationContext>())
                 .Returns(new ResolutionDetails<Value>(flagName2, defaultStructureValue, ErrorType.ProviderNotReady,
                     NoOpProvider.ReasonNoOp, NoOpProvider.Variant, testMessage));
 
-            providerMock.ResolveBooleanValue(flagName2, defaultBoolValue, Arg.Any<EvaluationContext>())
+            providerMock.ResolveBooleanValueAsync(flagName2, defaultBoolValue, Arg.Any<EvaluationContext>())
                 .Returns(new ResolutionDetails<bool>(flagName2, defaultBoolValue, ErrorType.TargetingKeyMissing,
                     NoOpProvider.ReasonNoOp, NoOpProvider.Variant));
 
-            var boolRes = await providerMock.ResolveBooleanValue(flagName, defaultBoolValue);
+            var boolRes = await providerMock.ResolveBooleanValueAsync(flagName, defaultBoolValue);
             boolRes.ErrorType.Should().Be(ErrorType.General);
             boolRes.ErrorMessage.Should().Be(testMessage);
 
-            var intRes = await providerMock.ResolveIntegerValue(flagName, defaultIntegerValue);
+            var intRes = await providerMock.ResolveIntegerValueAsync(flagName, defaultIntegerValue);
             intRes.ErrorType.Should().Be(ErrorType.ParseError);
             intRes.ErrorMessage.Should().Be(testMessage);
 
-            var doubleRes = await providerMock.ResolveDoubleValue(flagName, defaultDoubleValue);
+            var doubleRes = await providerMock.ResolveDoubleValueAsync(flagName, defaultDoubleValue);
             doubleRes.ErrorType.Should().Be(ErrorType.InvalidContext);
             doubleRes.ErrorMessage.Should().Be(testMessage);
 
-            var stringRes = await providerMock.ResolveStringValue(flagName, defaultStringValue);
+            var stringRes = await providerMock.ResolveStringValueAsync(flagName, defaultStringValue);
             stringRes.ErrorType.Should().Be(ErrorType.TypeMismatch);
             stringRes.ErrorMessage.Should().Be(testMessage);
 
-            var structRes1 = await providerMock.ResolveStructureValue(flagName, defaultStructureValue);
+            var structRes1 = await providerMock.ResolveStructureValueAsync(flagName, defaultStructureValue);
             structRes1.ErrorType.Should().Be(ErrorType.FlagNotFound);
             structRes1.ErrorMessage.Should().Be(testMessage);
 
-            var structRes2 = await providerMock.ResolveStructureValue(flagName2, defaultStructureValue);
+            var structRes2 = await providerMock.ResolveStructureValueAsync(flagName2, defaultStructureValue);
             structRes2.ErrorType.Should().Be(ErrorType.ProviderNotReady);
             structRes2.ErrorMessage.Should().Be(testMessage);
 
-            var boolRes2 = await providerMock.ResolveBooleanValue(flagName2, defaultBoolValue);
+            var boolRes2 = await providerMock.ResolveBooleanValueAsync(flagName2, defaultBoolValue);
             boolRes2.ErrorType.Should().Be(ErrorType.TargetingKeyMissing);
             boolRes2.ErrorMessage.Should().BeNull();
         }

test/OpenFeature.E2ETests/Steps/EvaluationStepDefinitions.cs

@@ -46,7 +46,7 @@ public async Task Event_Executor_Should_Propagate_Events_ToGlobal_Handler()
             eventHandler.Received().Invoke(Arg.Is<ProviderEventPayload>(payload => payload == myEvent.EventPayload));
 
             // shut down the event executor
-            await eventExecutor.Shutdown();
+            await eventExecutor.ShutdownAsync();
 
             // the next event should not be propagated to the event handler
             var newEventPayload = new ProviderEventPayload
@@ -78,9 +78,9 @@ public async Task API_Level_Event_Handlers_Should_Be_Registered()
             var testProvider = new TestProvider();
             await Api.Instance.SetProviderAsync(testProvider);
 
-            testProvider.SendEvent(ProviderEventTypes.ProviderConfigurationChanged);
-            testProvider.SendEvent(ProviderEventTypes.ProviderError);
-            testProvider.SendEvent(ProviderEventTypes.ProviderStale);
+            await testProvider.SendEventAsync(ProviderEventTypes.ProviderConfigurationChanged);
+            await testProvider.SendEventAsync(ProviderEventTypes.ProviderError);
+            await testProvider.SendEventAsync(ProviderEventTypes.ProviderStale);
 
             await Utils.AssertUntilAsync(_ => eventHandler
                 .Received()
@@ -148,7 +148,7 @@ public async Task API_Level_Event_Handlers_Should_Be_Informed_About_Ready_State_
 
             var testProvider = new TestProvider();
 #pragma warning disable CS0618// Type or member is obsolete
-            Api.Instance.SetProvider(testProvider);
+            await Api.Instance.SetProviderAsync(testProvider);
 #pragma warning restore CS0618// Type or member is obsolete
 
             Api.Instance.AddHandler(ProviderEventTypes.ProviderReady, eventHandler);
@@ -228,12 +228,12 @@ public async Task API_Level_Event_Handlers_Should_Be_Exchangeable()
             var testProvider = new TestProvider();
             await Api.Instance.SetProviderAsync(testProvider);
 
-            testProvider.SendEvent(ProviderEventTypes.ProviderConfigurationChanged);
+            await testProvider.SendEventAsync(ProviderEventTypes.ProviderConfigurationChanged);
 
             var newTestProvider = new TestProvider();
             await Api.Instance.SetProviderAsync(newTestProvider);
 
-            newTestProvider.SendEvent(ProviderEventTypes.ProviderConfigurationChanged);
+            await newTestProvider.SendEventAsync(ProviderEventTypes.ProviderConfigurationChanged);
 
             await Utils.AssertUntilAsync(
                 _ => eventHandler.Received(2).Invoke(Arg.Is<ProviderEventPayload>(payload => payload.ProviderName == testProvider.GetMetadata().Name && payload.Type == ProviderEventTypes.ProviderReady))
@@ -407,7 +407,7 @@ public async Task Client_Level_Event_Handlers_Should_Be_Receive_Events_From_Name
 
             client.AddHandler(ProviderEventTypes.ProviderConfigurationChanged, clientEventHandler);
 
-            defaultProvider.SendEvent(ProviderEventTypes.ProviderConfigurationChanged);
+            await defaultProvider.SendEventAsync(ProviderEventTypes.ProviderConfigurationChanged);
 
             // verify that the client received the event from the default provider as there is no named provider registered yet
             await Utils.AssertUntilAsync(
@@ -419,8 +419,8 @@ await Utils.AssertUntilAsync(
             await Api.Instance.SetProviderAsync(client.GetMetadata().Name!, clientProvider);
 
             // now, send another event for the default handler
-            defaultProvider.SendEvent(ProviderEventTypes.ProviderConfigurationChanged);
-            clientProvider.SendEvent(ProviderEventTypes.ProviderConfigurationChanged);
+            await defaultProvider.SendEventAsync(ProviderEventTypes.ProviderConfigurationChanged);
+            await clientProvider.SendEventAsync(ProviderEventTypes.ProviderConfigurationChanged);
 
             // now the client should have received only the event from the named provider
             await Utils.AssertUntilAsync(
@@ -479,7 +479,7 @@ public async Task Client_Level_Event_Handlers_Should_Be_Removable()
             await Utils.AssertUntilAsync(_ => myClient.RemoveHandler(ProviderEventTypes.ProviderReady, eventHandler));
 
             // send another event from the provider - this one should not be received
-            testProvider.SendEvent(ProviderEventTypes.ProviderReady);
+            await testProvider.SendEventAsync(ProviderEventTypes.ProviderReady);
 
             // wait a bit and make sure we only have received the first event, but nothing after removing the event handler
             await Utils.AssertUntilAsync(

test/OpenFeature.Tests/FeatureProviderTests.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
@@ -32,13 +31,13 @@ public async Task OpenFeature_Should_Initialize_Provider()
             providerMockDefault.GetStatus().Returns(ProviderStatus.NotReady);
 
             await Api.Instance.SetProviderAsync(providerMockDefault);
-            await providerMockDefault.Received(1).Initialize(Api.Instance.GetContext());
+            await providerMockDefault.Received(1).InitializeAsync(Api.Instance.GetContext());
 
             var providerMockNamed = Substitute.For<FeatureProvider>();
             providerMockNamed.GetStatus().Returns(ProviderStatus.NotReady);
 
             await Api.Instance.SetProviderAsync("the-name", providerMockNamed);
-            await providerMockNamed.Received(1).Initialize(Api.Instance.GetContext());
+            await providerMockNamed.Received(1).InitializeAsync(Api.Instance.GetContext());
         }
 
         [Fact]
@@ -50,27 +49,27 @@ public async Task OpenFeature_Should_Shutdown_Unused_Provider()
             providerA.GetStatus().Returns(ProviderStatus.NotReady);
 
             await Api.Instance.SetProviderAsync(providerA);
-            await providerA.Received(1).Initialize(Api.Instance.GetContext());
+            await providerA.Received(1).InitializeAsync(Api.Instance.GetContext());
 
             var providerB = Substitute.For<FeatureProvider>();
             providerB.GetStatus().Returns(ProviderStatus.NotReady);
 
             await Api.Instance.SetProviderAsync(providerB);
-            await providerB.Received(1).Initialize(Api.Instance.GetContext());
-            await providerA.Received(1).Shutdown();
+            await providerB.Received(1).InitializeAsync(Api.Instance.GetContext());
+            await providerA.Received(1).ShutdownAsync();
 
             var providerC = Substitute.For<FeatureProvider>();
             providerC.GetStatus().Returns(ProviderStatus.NotReady);
 
             await Api.Instance.SetProviderAsync("named", providerC);
-            await providerC.Received(1).Initialize(Api.Instance.GetContext());
+            await providerC.Received(1).InitializeAsync(Api.Instance.GetContext());
 
             var providerD = Substitute.For<FeatureProvider>();
             providerD.GetStatus().Returns(ProviderStatus.NotReady);
 
             await Api.Instance.SetProviderAsync("named", providerD);
-            await providerD.Received(1).Initialize(Api.Instance.GetContext());
-            await providerC.Received(1).Shutdown();
+            await providerD.Received(1).InitializeAsync(Api.Instance.GetContext());
+            await providerC.Received(1).ShutdownAsync();
         }
 
         [Fact]
@@ -86,10 +85,10 @@ public async Task OpenFeature_Should_Support_Shutdown()
             await Api.Instance.SetProviderAsync(providerA);
             await Api.Instance.SetProviderAsync("named", providerB);
 
-            await Api.Instance.Shutdown();
+            await Api.Instance.ShutdownAsync();
 
-            await providerA.Received(1).Shutdown();
-            await providerB.Received(1).Shutdown();
+            await providerA.Received(1).ShutdownAsync();
+            await providerB.Received(1).ShutdownAsync();
         }
 
         [Fact]
@@ -128,8 +127,8 @@ public async Task OpenFeature_Should_Assign_Provider_To_Existing_Client()
             const string name = "new-client";
             var openFeature = Api.Instance;
 
-            await openFeature.SetProviderAsync(name, new TestProvider()).ConfigureAwait(true);
-            await openFeature.SetProviderAsync(name, new NoOpFeatureProvider()).ConfigureAwait(true);
+            await openFeature.SetProviderAsync(name, new TestProvider());
+            await openFeature.SetProviderAsync(name, new NoOpFeatureProvider());
 
             openFeature.GetProviderMetadata(name).Name.Should().Be(NoOpProvider.NoOpProviderName);
         }
@@ -141,8 +140,8 @@ public async Task OpenFeature_Should_Allow_Multiple_Client_Names_Of_Same_Instanc
             var openFeature = Api.Instance;
             var provider = new TestProvider();
 
-            await openFeature.SetProviderAsync("a", provider).ConfigureAwait(true);
-            await openFeature.SetProviderAsync("b", provider).ConfigureAwait(true);
+            await openFeature.SetProviderAsync("a", provider);
+            await openFeature.SetProviderAsync("b", provider);
 
             var clientA = openFeature.GetProvider("a");
             var clientB = openFeature.GetProvider("b");
@@ -233,28 +232,17 @@ public async Task OpenFeature_Should_Allow_Multiple_Client_Mapping()
         {
             var openFeature = Api.Instance;
 
-            await openFeature.SetProviderAsync("client1", new TestProvider()).ConfigureAwait(true);
-            await openFeature.SetProviderAsync("client2", new NoOpFeatureProvider()).ConfigureAwait(true);
+            await openFeature.SetProviderAsync("client1", new TestProvider());
+            await openFeature.SetProviderAsync("client2", new NoOpFeatureProvider());
 
             var client1 = openFeature.GetClient("client1");
             var client2 = openFeature.GetClient("client2");
 
             client1.GetMetadata().Name.Should().Be("client1");
             client2.GetMetadata().Name.Should().Be("client2");
 
-            (await client1.GetBooleanValue("test", false)).Should().BeTrue();
-            (await client2.GetBooleanValue("test", false)).Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task SetProviderAsync_Should_Throw_When_Null_ClientName()
-        {
-            var openFeature = Api.Instance;
-
-            var exception = await Assert.ThrowsAsync<ArgumentNullException>(() => openFeature.SetProviderAsync(null!, new TestProvider()));
-
-            exception.Should().BeOfType<ArgumentNullException>();
-            exception.ParamName.Should().Be("clientName");
+            (await client1.GetBooleanValueAsync("test", false)).Should().BeTrue();
+            (await client2.GetBooleanValueAsync("test", false)).Should().BeFalse();
         }
     }
 }

test/OpenFeature.Tests/OpenFeatureClientTests.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
 using OpenFeature.Constant;
 using OpenFeature.Error;
 using OpenFeature.Model;
@@ -109,45 +110,45 @@ public InMemoryProviderTests()
         }
 
         [Fact]
-        public async void GetBoolean_ShouldEvaluateWithReasonAndVariant()
+        public async Task GetBoolean_ShouldEvaluateWithReasonAndVariant()
         {
-            ResolutionDetails<bool> details = await this.commonProvider.ResolveBooleanValue("boolean-flag", false, EvaluationContext.Empty);
+            ResolutionDetails<bool> details = await this.commonProvider.ResolveBooleanValueAsync("boolean-flag", false, EvaluationContext.Empty);
             Assert.True(details.Value);
             Assert.Equal(Reason.Static, details.Reason);
             Assert.Equal("on", details.Variant);
         }
 
         [Fact]
-        public async void GetString_ShouldEvaluateWithReasonAndVariant()
+        public async Task GetString_ShouldEvaluateWithReasonAndVariant()
         {
-            ResolutionDetails<string> details = await this.commonProvider.ResolveStringValue("string-flag", "nope", EvaluationContext.Empty);
+            ResolutionDetails<string> details = await this.commonProvider.ResolveStringValueAsync("string-flag", "nope", EvaluationContext.Empty);
             Assert.Equal("hi", details.Value);
             Assert.Equal(Reason.Static, details.Reason);
             Assert.Equal("greeting", details.Variant);
         }
 
         [Fact]
-        public async void GetInt_ShouldEvaluateWithReasonAndVariant()
+        public async Task GetInt_ShouldEvaluateWithReasonAndVariant()
         {
-            ResolutionDetails<int> details = await this.commonProvider.ResolveIntegerValue("integer-flag", 13, EvaluationContext.Empty);
+            ResolutionDetails<int> details = await this.commonProvider.ResolveIntegerValueAsync("integer-flag", 13, EvaluationContext.Empty);
             Assert.Equal(10, details.Value);
             Assert.Equal(Reason.Static, details.Reason);
             Assert.Equal("ten", details.Variant);
         }
 
         [Fact]
-        public async void GetDouble_ShouldEvaluateWithReasonAndVariant()
+        public async Task GetDouble_ShouldEvaluateWithReasonAndVariant()
         {
-            ResolutionDetails<double> details = await this.commonProvider.ResolveDoubleValue("float-flag", 13, EvaluationContext.Empty);
+            ResolutionDetails<double> details = await this.commonProvider.ResolveDoubleValueAsync("float-flag", 13, EvaluationContext.Empty);
             Assert.Equal(0.5, details.Value);
             Assert.Equal(Reason.Static, details.Reason);
             Assert.Equal("half", details.Variant);
         }
 
         [Fact]
-        public async void GetStruct_ShouldEvaluateWithReasonAndVariant()
+        public async Task GetStruct_ShouldEvaluateWithReasonAndVariant()
         {
-            ResolutionDetails<Value> details = await this.commonProvider.ResolveStructureValue("object-flag", new Value(), EvaluationContext.Empty);
+            ResolutionDetails<Value> details = await this.commonProvider.ResolveStructureValueAsync("object-flag", new Value(), EvaluationContext.Empty);
             Assert.Equal(true, details.Value.AsStructure?["showImages"].AsBoolean);
             Assert.Equal("Check out these pics!", details.Value.AsStructure?["title"].AsString);
             Assert.Equal(100, details.Value.AsStructure?["imagesPerPage"].AsInteger);
@@ -156,49 +157,49 @@ public async void GetStruct_ShouldEvaluateWithReasonAndVariant()
         }
 
         [Fact]
-        public async void GetString_ContextSensitive_ShouldEvaluateWithReasonAndVariant()
+        public async Task GetString_ContextSensitive_ShouldEvaluateWithReasonAndVariant()
         {
             EvaluationContext context = EvaluationContext.Builder().Set("email", "me@faas.com").Build();
-            ResolutionDetails<string> details = await this.commonProvider.ResolveStringValue("context-aware", "nope", context);
+            ResolutionDetails<string> details = await this.commonProvider.ResolveStringValueAsync("context-aware", "nope", context);
             Assert.Equal("INTERNAL", details.Value);
             Assert.Equal(Reason.TargetingMatch, details.Reason);
             Assert.Equal("internal", details.Variant);
         }
 
         [Fact]
-        public async void EmptyFlags_ShouldWork()
+        public async Task EmptyFlags_ShouldWork()
         {
             var provider = new InMemoryProvider();
             await provider.UpdateFlags();
             Assert.Equal("InMemory", provider.GetMetadata().Name);
         }
 
         [Fact]
-        public async void MissingFlag_ShouldThrow()
+        public async Task MissingFlag_ShouldThrow()
         {
-            await Assert.ThrowsAsync<FlagNotFoundException>(() => this.commonProvider.ResolveBooleanValue("missing-flag", false, EvaluationContext.Empty));
+            await Assert.ThrowsAsync<FlagNotFoundException>(() => this.commonProvider.ResolveBooleanValueAsync("missing-flag", false, EvaluationContext.Empty));
         }
 
         [Fact]
-        public async void MismatchedFlag_ShouldThrow()
+        public async Task MismatchedFlag_ShouldThrow()
         {
-            await Assert.ThrowsAsync<TypeMismatchException>(() => this.commonProvider.ResolveStringValue("boolean-flag", "nope", EvaluationContext.Empty));
+            await Assert.ThrowsAsync<TypeMismatchException>(() => this.commonProvider.ResolveStringValueAsync("boolean-flag", "nope", EvaluationContext.Empty));
         }
 
         [Fact]
-        public async void MissingDefaultVariant_ShouldThrow()
+        public async Task MissingDefaultVariant_ShouldThrow()
         {
-            await Assert.ThrowsAsync<GeneralException>(() => this.commonProvider.ResolveBooleanValue("invalid-flag", false, EvaluationContext.Empty));
+            await Assert.ThrowsAsync<GeneralException>(() => this.commonProvider.ResolveBooleanValueAsync("invalid-flag", false, EvaluationContext.Empty));
         }
 
         [Fact]
-        public async void MissingEvaluatedVariant_ShouldThrow()
+        public async Task MissingEvaluatedVariant_ShouldThrow()
         {
-            await Assert.ThrowsAsync<GeneralException>(() => this.commonProvider.ResolveBooleanValue("invalid-evaluator-flag", false, EvaluationContext.Empty));
+            await Assert.ThrowsAsync<GeneralException>(() => this.commonProvider.ResolveBooleanValueAsync("invalid-evaluator-flag", false, EvaluationContext.Empty));
         }
 
         [Fact]
-        public async void PutConfiguration_shouldUpdateConfigAndRunHandlers()
+        public async Task PutConfiguration_shouldUpdateConfigAndRunHandlers()
         {
             var provider = new InMemoryProvider(new Dictionary<string, Flag>(){
             {
@@ -211,7 +212,7 @@ public async void PutConfiguration_shouldUpdateConfigAndRunHandlers()
                 )
             }});
 
-            ResolutionDetails<bool> details = await provider.ResolveBooleanValue("old-flag", false, EvaluationContext.Empty);
+            ResolutionDetails<bool> details = await provider.ResolveBooleanValueAsync("old-flag", false, EvaluationContext.Empty);
             Assert.True(details.Value);
 
             // update flags
@@ -229,10 +230,10 @@ await provider.UpdateFlags(new Dictionary<string, Flag>(){
             var res = await provider.GetEventChannel().Reader.ReadAsync() as ProviderEventPayload;
             Assert.Equal(ProviderEventTypes.ProviderConfigurationChanged, res?.Type);
 
-            await Assert.ThrowsAsync<FlagNotFoundException>(() => provider.ResolveBooleanValue("old-flag", false, EvaluationContext.Empty));
+            await Assert.ThrowsAsync<FlagNotFoundException>(() => provider.ResolveBooleanValueAsync("old-flag", false, EvaluationContext.Empty));
 
             // new flag should be present, old gone (defaults), handler run.
-            ResolutionDetails<string> detailsAfter = await provider.ResolveStringValue("new-flag", "nope", EvaluationContext.Empty);
+            ResolutionDetails<string> detailsAfter = await provider.ResolveStringValueAsync("new-flag", "nope", EvaluationContext.Empty);
             Assert.True(details.Value);
             Assert.Equal("hi", detailsAfter.Value);
         }

test/OpenFeature.Tests/OpenFeatureEventTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Threading;
 using System.Threading.Tasks;
 using OpenFeature.Constant;
 using OpenFeature.Model;
@@ -11,25 +12,25 @@ public class TestHookNoOverride : Hook { }
 
     public class TestHook : Hook
     {
-        public override Task<EvaluationContext> Before<T>(HookContext<T> context, IReadOnlyDictionary<string, object>? hints = null)
+        public override ValueTask<EvaluationContext> BeforeAsync<T>(HookContext<T> context, IReadOnlyDictionary<string, object>? hints = null, CancellationToken cancellationToken = default)
         {
-            return Task.FromResult(EvaluationContext.Empty);
+            return new ValueTask<EvaluationContext>(EvaluationContext.Empty);
         }
 
-        public override Task After<T>(HookContext<T> context, FlagEvaluationDetails<T> details,
-            IReadOnlyDictionary<string, object>? hints = null)
+        public override ValueTask AfterAsync<T>(HookContext<T> context, FlagEvaluationDetails<T> details,
+            IReadOnlyDictionary<string, object>? hints = null, CancellationToken cancellationToken = default)
         {
-            return Task.CompletedTask;
+            return new ValueTask();
         }
 
-        public override Task Error<T>(HookContext<T> context, Exception error, IReadOnlyDictionary<string, object>? hints = null)
+        public override ValueTask ErrorAsync<T>(HookContext<T> context, Exception error, IReadOnlyDictionary<string, object>? hints = null, CancellationToken cancellationToken = default)
         {
-            return Task.CompletedTask;
+            return new ValueTask();
         }
 
-        public override Task Finally<T>(HookContext<T> context, IReadOnlyDictionary<string, object>? hints = null)
+        public override ValueTask FinallyAsync<T>(HookContext<T> context, IReadOnlyDictionary<string, object>? hints = null, CancellationToken cancellationToken = default)
         {
-            return Task.CompletedTask;
+            return new ValueTask();
         }
     }
 
@@ -64,32 +65,32 @@ public override Metadata GetMetadata()
             return new Metadata(this.Name);
         }
 
-        public override Task<ResolutionDetails<bool>> ResolveBooleanValue(string flagKey, bool defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(string flagKey, bool defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(new ResolutionDetails<bool>(flagKey, !defaultValue));
         }
 
-        public override Task<ResolutionDetails<string>> ResolveStringValue(string flagKey, string defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey, string defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(new ResolutionDetails<string>(flagKey, defaultValue));
         }
 
-        public override Task<ResolutionDetails<int>> ResolveIntegerValue(string flagKey, int defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<int>> ResolveIntegerValueAsync(string flagKey, int defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(new ResolutionDetails<int>(flagKey, defaultValue));
         }
 
-        public override Task<ResolutionDetails<double>> ResolveDoubleValue(string flagKey, double defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey, double defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(new ResolutionDetails<double>(flagKey, defaultValue));
         }
 
-        public override Task<ResolutionDetails<Value>> ResolveStructureValue(string flagKey, Value defaultValue,
-            EvaluationContext? context = null)
+        public override Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey, Value defaultValue,
+            EvaluationContext? context = null, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(new ResolutionDetails<Value>(flagKey, defaultValue));
         }
@@ -104,16 +105,16 @@ public void SetStatus(ProviderStatus status)
             this._status = status;
         }
 
-        public override Task Initialize(EvaluationContext context)
+        public override async Task InitializeAsync(EvaluationContext context, CancellationToken cancellationToken = default)
         {
             this._status = ProviderStatus.Ready;
-            this.EventChannel.Writer.WriteAsync(new ProviderEventPayload { Type = ProviderEventTypes.ProviderReady, ProviderName = this.GetMetadata().Name });
-            return base.Initialize(context);
+            await this.EventChannel.Writer.WriteAsync(new ProviderEventPayload { Type = ProviderEventTypes.ProviderReady, ProviderName = this.GetMetadata().Name }, cancellationToken).ConfigureAwait(false);
+            await base.InitializeAsync(context, cancellationToken).ConfigureAwait(false);
         }
 
-        internal void SendEvent(ProviderEventTypes eventType)
+        internal ValueTask SendEventAsync(ProviderEventTypes eventType, CancellationToken cancellationToken = default)
         {
-            this.EventChannel.Writer.WriteAsync(new ProviderEventPayload { Type = eventType, ProviderName = this.GetMetadata().Name });
+            return this.EventChannel.Writer.WriteAsync(new ProviderEventPayload { Type = eventType, ProviderName = this.GetMetadata().Name }, cancellationToken);
         }
     }
 }

test/OpenFeature.Tests/OpenFeatureHookTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace OpenFeature.Tests
@@ -8,13 +9,13 @@ namespace OpenFeature.Tests
     public class TestUtilsTest
     {
         [Fact]
-        public async void Should_Fail_If_Assertion_Fails()
+        public async Task Should_Fail_If_Assertion_Fails()
         {
             await Assert.ThrowsAnyAsync<Exception>(() => Utils.AssertUntilAsync(_ => Assert.True(1.Equals(2)), 100, 10));
         }
 
         [Fact]
-        public async void Should_Pass_If_Assertion_Fails()
+        public async Task Should_Pass_If_Assertion_Fails()
         {
             await Utils.AssertUntilAsync(_ => Assert.True(1.Equals(1)));
         }