From 609016fc86f8eee8d848a9227b57aaef0d9b85b0 Mon Sep 17 00:00:00 2001
From: Ryan Lamb <4955475+kinyoklion@users.noreply.github.com>
Date: Wed, 12 Oct 2022 11:27:06 -0700
Subject: [PATCH] feat!: Thread safe hooks, provider, and context (#79)

---
 src/OpenFeatureSDK/FeatureProvider.cs         |   7 +-
 .../Model/FlagEvaluationOptions.cs            |  20 +--
 src/OpenFeatureSDK/OpenFeature.cs             | 114 +++++++++++++++---
 src/OpenFeatureSDK/OpenFeatureClient.cs       | 109 +++++++++++++----
 .../OpenFeatureClientTests.cs                 |  35 +++---
 .../OpenFeatureHookTests.cs                   |  38 +++---
 test/OpenFeatureSDK.Tests/OpenFeatureTests.cs |   9 +-
 .../TestImplementations.cs                    |   3 +-
 8 files changed, 245 insertions(+), 90 deletions(-)

diff --git a/src/OpenFeatureSDK/FeatureProvider.cs b/src/OpenFeatureSDK/FeatureProvider.cs
index 639363a8..e2934cea 100644
--- a/src/OpenFeatureSDK/FeatureProvider.cs
+++ b/src/OpenFeatureSDK/FeatureProvider.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Threading.Tasks;
 using OpenFeatureSDK.Model;
 
@@ -22,8 +21,8 @@ public abstract class FeatureProvider
         /// error (if applicable): Provider, Invocation, Client, API
         /// finally: Provider, Invocation, Client, API
         /// </summary>
-        /// <returns></returns>
-        public virtual IReadOnlyList<Hook> GetProviderHooks() => Array.Empty<Hook>();
+        /// <returns>Immutable list of hooks</returns>
+        public virtual IImmutableList<Hook> GetProviderHooks() => ImmutableList<Hook>.Empty;
 
         /// <summary>
         /// Metadata describing the provider.
diff --git a/src/OpenFeatureSDK/Model/FlagEvaluationOptions.cs b/src/OpenFeatureSDK/Model/FlagEvaluationOptions.cs
index cb8bc353..38396723 100644
--- a/src/OpenFeatureSDK/Model/FlagEvaluationOptions.cs
+++ b/src/OpenFeatureSDK/Model/FlagEvaluationOptions.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Immutable;
 
 namespace OpenFeatureSDK.Model
 {
@@ -12,33 +12,33 @@ public class FlagEvaluationOptions
         /// <summary>
         /// A immutable list of <see cref="Hook"/>
         /// </summary>
-        public IReadOnlyList<Hook> Hooks { get; }
+        public IImmutableList<Hook> Hooks { get; }
 
         /// <summary>
         /// A immutable dictionary of hook hints
         /// </summary>
-        public IReadOnlyDictionary<string, object> HookHints { get; }
+        public IImmutableDictionary<string, object> HookHints { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="FlagEvaluationOptions"/> class.
         /// </summary>
-        /// <param name="hooks"></param>
+        /// <param name="hooks">An immutable list of hooks to use during evaluation</param>
         /// <param name="hookHints">Optional - a list of hints that are passed through the hook lifecycle</param>
-        public FlagEvaluationOptions(IReadOnlyList<Hook> hooks, IReadOnlyDictionary<string, object> hookHints = null)
+        public FlagEvaluationOptions(IImmutableList<Hook> hooks, IImmutableDictionary<string, object> hookHints = null)
         {
             this.Hooks = hooks;
-            this.HookHints = hookHints ?? new Dictionary<string, object>();
+            this.HookHints = hookHints ?? ImmutableDictionary<string, object>.Empty;
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="FlagEvaluationOptions"/> class.
         /// </summary>
-        /// <param name="hook"></param>
+        /// <param name="hook">A hook to use during the evaluation</param>
         /// <param name="hookHints">Optional - a list of hints that are passed through the hook lifecycle</param>
-        public FlagEvaluationOptions(Hook hook, IReadOnlyDictionary<string, object> hookHints = null)
+        public FlagEvaluationOptions(Hook hook, ImmutableDictionary<string, object> hookHints = null)
         {
-            this.Hooks = new[] { hook };
-            this.HookHints = hookHints ?? new Dictionary<string, object>();
+            this.Hooks = ImmutableList.Create(hook);
+            this.HookHints = hookHints ?? ImmutableDictionary<string, object>.Empty;
         }
     }
 }
diff --git a/src/OpenFeatureSDK/OpenFeature.cs b/src/OpenFeatureSDK/OpenFeature.cs
index 42b23dcf..cf119f9f 100644
--- a/src/OpenFeatureSDK/OpenFeature.cs
+++ b/src/OpenFeatureSDK/OpenFeature.cs
@@ -1,4 +1,8 @@
+using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
 using Microsoft.Extensions.Logging;
 using OpenFeatureSDK.Model;
 
@@ -13,7 +17,11 @@ public sealed class OpenFeature
     {
         private EvaluationContext _evaluationContext = EvaluationContext.Empty;
         private FeatureProvider _featureProvider = new NoOpFeatureProvider();
-        private readonly List<Hook> _hooks = new List<Hook>();
+        private readonly ConcurrentStack<Hook> _hooks = new ConcurrentStack<Hook>();
+
+        /// The reader/writer locks are not disposed because the singleton instance should never be disposed.
+        private readonly ReaderWriterLockSlim _evaluationContextLock = new ReaderWriterLockSlim();
+        private readonly ReaderWriterLockSlim _featureProviderLock = new ReaderWriterLockSlim();
 
         /// <summary>
         /// Singleton instance of OpenFeature
@@ -30,19 +38,53 @@ private OpenFeature() { }
         /// Sets the feature provider
         /// </summary>
         /// <param name="featureProvider">Implementation of <see cref="FeatureProvider"/></param>
-        public void SetProvider(FeatureProvider featureProvider) => this._featureProvider = featureProvider;
+        public void SetProvider(FeatureProvider featureProvider)
+        {
+            this._featureProviderLock.EnterWriteLock();
+            try
+            {
+                this._featureProvider = featureProvider;
+            }
+            finally
+            {
+                this._featureProviderLock.ExitWriteLock();
+            }
+        }
 
         /// <summary>
         /// Gets the feature provider
+        /// <para>
+        /// The feature provider may be set from multiple threads, when accessing the global feature provider
+        /// it should be accessed once for an operation, and then that reference should be used for all dependent
+        /// operations. For instance, during an evaluation the flag resolution method, and the provider hooks
+        /// should be accessed from the same reference, not two independent calls to
+        /// <see cref="OpenFeature.GetProvider"/>.
+        /// </para>
         /// </summary>
         /// <returns><see cref="FeatureProvider"/></returns>
-        public FeatureProvider GetProvider() => this._featureProvider;
+        public FeatureProvider GetProvider()
+        {
+            this._featureProviderLock.EnterReadLock();
+            try
+            {
+                return this._featureProvider;
+            }
+            finally
+            {
+                this._featureProviderLock.ExitReadLock();
+            }
+        }
 
         /// <summary>
         /// Gets providers metadata
+        /// <para>
+        /// This method is not guaranteed to return the same provider instance that may be used during an evaluation
+        /// in the case where the provider may be changed from another thread.
+        /// For multiple dependent provider operations see <see cref="OpenFeature.GetProvider"/>.
+        /// </para>
         /// </summary>
         /// <returns><see cref="ClientMetadata"/></returns>
-        public Metadata GetProviderMetadata() => this._featureProvider.GetMetadata();
+        public Metadata GetProviderMetadata() => this.GetProvider().GetMetadata();
 
         /// <summary>
         /// Create a new instance of <see cref="FeatureClient"/> using the current provider
@@ -52,26 +94,39 @@ private OpenFeature() { }
         /// <param name="logger">Logger instance used by client</param>
         /// <param name="context">Context given to this client</param>
         /// <returns><see cref="FeatureClient"/></returns>
-        public FeatureClient GetClient(string name = null, string version = null, ILogger logger = null, EvaluationContext context = null) =>
-            new FeatureClient(this._featureProvider, name, version, logger, context);
+        public FeatureClient GetClient(string name = null, string version = null, ILogger logger = null,
+            EvaluationContext context = null) =>
+            new FeatureClient(name, version, logger, context);
 
         /// <summary>
         /// Appends list of hooks to global hooks list
+        /// <para>
+        /// The appending operation will be atomic.
+        /// </para>
         /// </summary>
         /// <param name="hooks">A list of <see cref="Hook"/></param>
-        public void AddHooks(IEnumerable<Hook> hooks) => this._hooks.AddRange(hooks);
+        public void AddHooks(IEnumerable<Hook> hooks) => this._hooks.PushRange(hooks.ToArray());
 
         /// <summary>
         /// Adds a hook to global hooks list
+        /// <para>
+        /// Hooks which are dependent on each other should be provided in a collection
+        /// using the <see cref="AddHooks(System.Collections.Generic.IEnumerable{OpenFeatureSDK.Hook})"/>.
+        /// </para>
         /// </summary>
-        /// <param name="hook">A list of <see cref="Hook"/></param>
-        public void AddHooks(Hook hook) => this._hooks.Add(hook);
+        /// <param name="hook">Hook that implements the <see cref="Hook"/> interface</param>
+        public void AddHooks(Hook hook) => this._hooks.Push(hook);
 
         /// <summary>
-        /// Returns the global immutable hooks list
+        /// Enumerates the global hooks.
+        /// <para>
+        /// The items enumerated will reflect the registered hooks
+        /// at the start of enumeration. Hooks added during enumeration
+        /// will not be included.
+        /// </para>
         /// </summary>
-        /// <returns>A immutable list of <see cref="Hook"/></returns>
-        public IReadOnlyList<Hook> GetHooks() => this._hooks.AsReadOnly();
+        /// <returns>Enumeration of <see cref="Hook"/></returns>
+        public IEnumerable<Hook> GetHooks() => this._hooks.Reverse();
 
         /// <summary>
         /// Removes all hooks from global hooks list
@@ -81,13 +136,40 @@ public FeatureClient GetClient(string name = null, string version = null, ILogge
         /// <summary>
         /// Sets the global <see cref="EvaluationContext"/>
         /// </summary>
-        /// <param name="context"></param>
-        public void SetContext(EvaluationContext context) => this._evaluationContext = context ?? EvaluationContext.Empty;
+        /// <param name="context">The <see cref="EvaluationContext"/> to set</param>
+        public void SetContext(EvaluationContext context)
+        {
+            this._evaluationContextLock.EnterWriteLock();
+            try
+            {
+                this._evaluationContext = context ?? EvaluationContext.Empty;
+            }
+            finally
+            {
+                this._evaluationContextLock.ExitWriteLock();
+            }
+        }
 
         /// <summary>
         /// Gets the global <see cref="EvaluationContext"/>
+        /// <para>
+        /// The evaluation context may be set from multiple threads, when accessing the global evaluation context
+        /// it should be accessed once for an operation, and then that reference should be used for all dependent
+        /// operations.
+        /// </para>
         /// </summary>
-        /// <returns></returns>
-        public EvaluationContext GetContext() => this._evaluationContext;
+        /// <returns>An <see cref="EvaluationContext"/></returns>
+        public EvaluationContext GetContext()
+        {
+            this._evaluationContextLock.EnterReadLock();
+            try
+            {
+                return this._evaluationContext;
+            }
+            finally
+            {
+                this._evaluationContextLock.ExitReadLock();
+            }
+        }
     }
 }
diff --git a/src/OpenFeatureSDK/OpenFeatureClient.cs b/src/OpenFeatureSDK/OpenFeatureClient.cs
index 3d4120b7..efe47cb6 100644
--- a/src/OpenFeatureSDK/OpenFeatureClient.cs
+++ b/src/OpenFeatureSDK/OpenFeatureClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -17,34 +18,80 @@ namespace OpenFeatureSDK
     public sealed class FeatureClient : IFeatureClient
     {
         private readonly ClientMetadata _metadata;
-        private readonly FeatureProvider _featureProvider;
-        private readonly List<Hook> _hooks = new List<Hook>();
+        private readonly ConcurrentStack<Hook> _hooks = new ConcurrentStack<Hook>();
         private readonly ILogger _logger;
         private EvaluationContext _evaluationContext;
 
+        private readonly object _evaluationContextLock = new object();
+
+        /// <summary>
+        /// Get a provider and an associated typed flag resolution method.
+        /// <para>
+        /// The global provider could change between two accesses, so in order to safely get provider information we
+        /// must first alias it and then use that alias to access everything we need.
+        /// </para>
+        /// </summary>
+        /// <param name="method">
+        ///     This method should return the desired flag resolution method from the given provider reference.
+        /// </param>
+        /// <typeparam name="T">The type of the resolution method</typeparam>
+        /// <returns>A tuple containing a resolution method and the provider it came from.</returns>
+        private (Func<string, T, EvaluationContext, Task<ResolutionDetails<T>>>, FeatureProvider)
+            ExtractProvider<T>(
+                Func<FeatureProvider, Func<string, T, EvaluationContext, Task<ResolutionDetails<T>>>> method)
+        {
+            // Alias the provider reference so getting the method and returning the provider are
+            // guaranteed to be the same object.
+            var provider = OpenFeature.Instance.GetProvider();
+
+            if (provider == null)
+            {
+                provider = new NoOpFeatureProvider();
+                this._logger.LogDebug("No provider configured, using no-op provider");
+            }
+
+            return (method(provider), provider);
+        }
+
         /// <summary>
         /// Gets the EvaluationContext of this client<see cref="EvaluationContext"/>
+        /// <para>
+        /// The evaluation context may be set from multiple threads, when accessing the client evaluation context
+        /// it should be accessed once for an operation, and then that reference should be used for all dependent
+        /// operations.
+        /// </para>
         /// </summary>
         /// <returns><see cref="EvaluationContext"/>of this client</returns>
-        public EvaluationContext GetContext() => this._evaluationContext;
+        public EvaluationContext GetContext()
+        {
+            lock (this._evaluationContextLock)
+            {
+                return this._evaluationContext;
+            }
+        }
 
         /// <summary>
         /// Sets the EvaluationContext of the client<see cref="EvaluationContext"/>
         /// </summary>
-        public void SetContext(EvaluationContext evaluationContext) => this._evaluationContext = evaluationContext;
+        /// <param name="context">The <see cref="EvaluationContext"/> to set</param>
+        public void SetContext(EvaluationContext context)
+        {
+            lock (this._evaluationContextLock)
+            {
+                this._evaluationContext = context ?? EvaluationContext.Empty;
+            }
+        }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="FeatureClient"/> class.
         /// </summary>
-        /// <param name="featureProvider">Feature provider used by client <see cref="FeatureProvider"/></param>
         /// <param name="name">Name of client <see cref="ClientMetadata"/></param>
         /// <param name="version">Version of client <see cref="ClientMetadata"/></param>
         /// <param name="logger">Logger used by client</param>
         /// <param name="context">Context given to this client</param>
         /// <exception cref="ArgumentNullException">Throws if any of the required parameters are null</exception>
-        public FeatureClient(FeatureProvider featureProvider, string name, string version, ILogger logger = null, EvaluationContext context = null)
+        public FeatureClient(string name, string version, ILogger logger = null, EvaluationContext context = null)
         {
-            this._featureProvider = featureProvider ?? throw new ArgumentNullException(nameof(featureProvider));
             this._metadata = new ClientMetadata(name, version);
             this._logger = logger ?? new Logger<OpenFeature>(new NullLoggerFactory());
             this._evaluationContext = context ?? EvaluationContext.Empty;
@@ -58,21 +105,33 @@ public FeatureClient(FeatureProvider featureProvider, string name, string versio
 
         /// <summary>
         /// Add hook to client
+        /// <para>
+        /// Hooks which are dependent on each other should be provided in a collection
+        /// using the <see cref="AddHooks(System.Collections.Generic.IEnumerable{OpenFeatureSDK.Hook})"/>.
+        /// </para>
         /// </summary>
         /// <param name="hook">Hook that implements the <see cref="Hook"/> interface</param>
-        public void AddHooks(Hook hook) => this._hooks.Add(hook);
+        public void AddHooks(Hook hook) => this._hooks.Push(hook);
 
         /// <summary>
         /// Appends hooks to client
+        /// <para>
+        /// The appending operation will be atomic.
+        /// </para>
         /// </summary>
         /// <param name="hooks">A list of Hooks that implement the <see cref="Hook"/> interface</param>
-        public void AddHooks(IEnumerable<Hook> hooks) => this._hooks.AddRange(hooks);
+        public void AddHooks(IEnumerable<Hook> hooks) => this._hooks.PushRange(hooks.ToArray());
 
         /// <summary>
-        /// Return a immutable list of hooks that are registered against the client
+        /// Enumerates the global hooks.
+        /// <para>
+        /// The items enumerated will reflect the registered hooks
+        /// at the start of enumeration. Hooks added during enumeration
+        /// will not be included.
+        /// </para>
         /// </summary>
-        /// <returns>A list of immutable hooks</returns>
-        public IReadOnlyList<Hook> GetHooks() => this._hooks.ToList().AsReadOnly();
+        /// <returns>Enumeration of <see cref="Hook"/></returns>
+        public IEnumerable<Hook> GetHooks() => this._hooks.Reverse();
 
         /// <summary>
         /// Removes all hooks from the client
@@ -101,7 +160,8 @@ public async Task<bool> GetBooleanValue(string flagKey, bool defaultValue, Evalu
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
         public async Task<FlagEvaluationDetails<bool>> GetBooleanDetails(string flagKey, bool defaultValue,
             EvaluationContext context = null, FlagEvaluationOptions config = null) =>
-            await this.EvaluateFlag(this._featureProvider.ResolveBooleanValue, FlagValueType.Boolean, flagKey,
+            await this.EvaluateFlag(this.ExtractProvider<bool>(provider => provider.ResolveBooleanValue),
+                FlagValueType.Boolean, flagKey,
                 defaultValue, context, config);
 
         /// <summary>
@@ -126,7 +186,8 @@ public async Task<string> GetStringValue(string flagKey, string defaultValue, Ev
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
         public async Task<FlagEvaluationDetails<string>> GetStringDetails(string flagKey, string defaultValue,
             EvaluationContext context = null, FlagEvaluationOptions config = null) =>
-            await this.EvaluateFlag(this._featureProvider.ResolveStringValue, FlagValueType.String, flagKey,
+            await this.EvaluateFlag(this.ExtractProvider<string>(provider => provider.ResolveStringValue),
+                FlagValueType.String, flagKey,
                 defaultValue, context, config);
 
         /// <summary>
@@ -151,7 +212,8 @@ public async Task<int> GetIntegerValue(string flagKey, int defaultValue, Evaluat
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
         public async Task<FlagEvaluationDetails<int>> GetIntegerDetails(string flagKey, int defaultValue,
             EvaluationContext context = null, FlagEvaluationOptions config = null) =>
-            await this.EvaluateFlag(this._featureProvider.ResolveIntegerValue, FlagValueType.Number, flagKey,
+            await this.EvaluateFlag(this.ExtractProvider<int>(provider => provider.ResolveIntegerValue),
+                FlagValueType.Number, flagKey,
                 defaultValue, context, config);
 
         /// <summary>
@@ -177,7 +239,8 @@ public async Task<double> GetDoubleValue(string flagKey, double defaultValue,
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
         public async Task<FlagEvaluationDetails<double>> GetDoubleDetails(string flagKey, double defaultValue,
             EvaluationContext context = null, FlagEvaluationOptions config = null) =>
-            await this.EvaluateFlag(this._featureProvider.ResolveDoubleValue, FlagValueType.Number, flagKey,
+            await this.EvaluateFlag(this.ExtractProvider<double>(provider => provider.ResolveDoubleValue),
+                FlagValueType.Number, flagKey,
                 defaultValue, context, config);
 
         /// <summary>
@@ -202,14 +265,18 @@ public async Task<Value> GetObjectValue(string flagKey, Value defaultValue, Eval
         /// <returns>Resolved flag details <see cref="FlagEvaluationDetails{T}"/></returns>
         public async Task<FlagEvaluationDetails<Value>> GetObjectDetails(string flagKey, Value defaultValue,
             EvaluationContext context = null, FlagEvaluationOptions config = null) =>
-            await this.EvaluateFlag(this._featureProvider.ResolveStructureValue, FlagValueType.Object, flagKey,
+            await this.EvaluateFlag(this.ExtractProvider<Value>(provider => provider.ResolveStructureValue),
+                FlagValueType.Object, flagKey,
                 defaultValue, context, config);
 
         private async Task<FlagEvaluationDetails<T>> EvaluateFlag<T>(
-            Func<string, T, EvaluationContext, Task<ResolutionDetails<T>>> resolveValueDelegate,
+            (Func<string, T, EvaluationContext, Task<ResolutionDetails<T>>>, FeatureProvider) providerInfo,
             FlagValueType flagValueType, string flagKey, T defaultValue, EvaluationContext context = null,
             FlagEvaluationOptions options = null)
         {
+            var resolveValueDelegate = providerInfo.Item1;
+            var provider = providerInfo.Item2;
+
             // New up a evaluation context if one was not provided.
             if (context == null)
             {
@@ -225,9 +292,9 @@ private async Task<FlagEvaluationDetails<T>> EvaluateFlag<T>(
 
             var allHooks = new List<Hook>()
                 .Concat(OpenFeature.Instance.GetHooks())
-                .Concat(this._hooks)
+                .Concat(this.GetHooks())
                 .Concat(options?.Hooks ?? Enumerable.Empty<Hook>())
-                .Concat(this._featureProvider.GetProviderHooks())
+                .Concat(provider.GetProviderHooks())
                 .ToList()
                 .AsReadOnly();
 
@@ -241,7 +308,7 @@ private async Task<FlagEvaluationDetails<T>> EvaluateFlag<T>(
                 flagKey,
                 defaultValue,
                 flagValueType, this._metadata,
-                OpenFeature.Instance.GetProviderMetadata(),
+                provider.GetMetadata(),
                 evaluationContextBuilder.Build()
             );
 
diff --git a/test/OpenFeatureSDK.Tests/OpenFeatureClientTests.cs b/test/OpenFeatureSDK.Tests/OpenFeatureClientTests.cs
index 6babbdf5..519fe452 100644
--- a/test/OpenFeatureSDK.Tests/OpenFeatureClientTests.cs
+++ b/test/OpenFeatureSDK.Tests/OpenFeatureClientTests.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
 using System.Threading.Tasks;
 using AutoFixture;
 using FluentAssertions;
@@ -30,14 +32,14 @@ public void OpenFeatureClient_Should_Allow_Hooks()
             client.AddHooks(new[] { hook1, hook2 });
 
             client.GetHooks().Should().ContainInOrder(hook1, hook2);
-            client.GetHooks().Count.Should().Be(2);
+            client.GetHooks().Count().Should().Be(2);
 
             client.AddHooks(hook3);
             client.GetHooks().Should().ContainInOrder(hook1, hook2, hook3);
-            client.GetHooks().Count.Should().Be(3);
+            client.GetHooks().Count().Should().Be(3);
 
             client.ClearHooks();
-            client.GetHooks().Count.Should().Be(0);
+            Assert.Empty(client.GetHooks());
         }
 
         [Fact]
@@ -68,7 +70,7 @@ public async Task OpenFeatureClient_Should_Allow_Flag_Evaluation()
             var defaultIntegerValue = fixture.Create<int>();
             var defaultDoubleValue = fixture.Create<double>();
             var defaultStructureValue = fixture.Create<Value>();
-            var emptyFlagOptions = new FlagEvaluationOptions(new List<Hook>(), new Dictionary<string, object>());
+            var emptyFlagOptions = new FlagEvaluationOptions(ImmutableList<Hook>.Empty, ImmutableDictionary<string, object>.Empty);
 
             OpenFeature.Instance.SetProvider(new NoOpFeatureProvider());
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion);
@@ -114,7 +116,7 @@ public async Task OpenFeatureClient_Should_Allow_Details_Flag_Evaluation()
             var defaultIntegerValue = fixture.Create<int>();
             var defaultDoubleValue = fixture.Create<double>();
             var defaultStructureValue = fixture.Create<Value>();
-            var emptyFlagOptions = new FlagEvaluationOptions(new List<Hook>(), new Dictionary<string, object>());
+            var emptyFlagOptions = new FlagEvaluationOptions(ImmutableList<Hook>.Empty, ImmutableDictionary<string, object>.Empty);
 
             OpenFeature.Instance.SetProvider(new NoOpFeatureProvider());
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion);
@@ -169,7 +171,7 @@ public async Task OpenFeatureClient_Should_Return_DefaultValue_When_Type_Mismatc
             mockedFeatureProvider.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(fixture.Create<string>()));
             mockedFeatureProvider.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             OpenFeature.Instance.SetProvider(mockedFeatureProvider.Object);
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion, mockedLogger.Object);
@@ -206,7 +208,7 @@ public async Task Should_Resolve_BooleanValue()
             featureProviderMock.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(fixture.Create<string>()));
             featureProviderMock.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             OpenFeature.Instance.SetProvider(featureProviderMock.Object);
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion);
@@ -232,7 +234,7 @@ public async Task Should_Resolve_StringValue()
             featureProviderMock.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(fixture.Create<string>()));
             featureProviderMock.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             OpenFeature.Instance.SetProvider(featureProviderMock.Object);
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion);
@@ -258,7 +260,7 @@ public async Task Should_Resolve_IntegerValue()
             featureProviderMock.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(fixture.Create<string>()));
             featureProviderMock.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             OpenFeature.Instance.SetProvider(featureProviderMock.Object);
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion);
@@ -284,7 +286,7 @@ public async Task Should_Resolve_DoubleValue()
             featureProviderMock.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(fixture.Create<string>()));
             featureProviderMock.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             OpenFeature.Instance.SetProvider(featureProviderMock.Object);
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion);
@@ -310,7 +312,7 @@ public async Task Should_Resolve_StructureValue()
             featureProviderMock.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(fixture.Create<string>()));
             featureProviderMock.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             OpenFeature.Instance.SetProvider(featureProviderMock.Object);
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion);
@@ -338,7 +340,7 @@ public async Task When_Error_Is_Returned_From_Provider_Should_Return_Error()
             featureProviderMock.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(fixture.Create<string>()));
             featureProviderMock.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             OpenFeature.Instance.SetProvider(featureProviderMock.Object);
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion);
@@ -367,7 +369,7 @@ public async Task When_Exception_Occurs_During_Evaluation_Should_Return_Error()
             featureProviderMock.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(fixture.Create<string>()));
             featureProviderMock.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             OpenFeature.Instance.SetProvider(featureProviderMock.Object);
             var client = OpenFeature.Instance.GetClient(clientName, clientVersion);
@@ -380,10 +382,11 @@ public async Task When_Exception_Occurs_During_Evaluation_Should_Return_Error()
         }
 
         [Fact]
-        public void Should_Throw_ArgumentNullException_When_Provider_Is_Null()
+        public async Task Should_Use_No_Op_When_Provider_Is_Null()
         {
-            TestProvider provider = null;
-            Assert.Throws<ArgumentNullException>(() => new FeatureClient(provider, "test", "test"));
+            OpenFeature.Instance.SetProvider(null);
+            var client = new FeatureClient("test", "test");
+            (await client.GetIntegerValue("some-key", 12)).Should().Be(12);
         }
 
         [Fact]
diff --git a/test/OpenFeatureSDK.Tests/OpenFeatureHookTests.cs b/test/OpenFeatureSDK.Tests/OpenFeatureHookTests.cs
index 0c97e18b..3b13e6b8 100644
--- a/test/OpenFeatureSDK.Tests/OpenFeatureHookTests.cs
+++ b/test/OpenFeatureSDK.Tests/OpenFeatureHookTests.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
 using System.Threading.Tasks;
 using AutoFixture;
 using FluentAssertions;
@@ -83,7 +85,7 @@ public async Task Hooks_Should_Be_Called_In_Order()
             client.AddHooks(clientHook.Object);
 
             await client.GetBooleanValue(flagName, defaultValue, EvaluationContext.Empty,
-                new FlagEvaluationOptions(invocationHook.Object, new Dictionary<string, object>()));
+                new FlagEvaluationOptions(invocationHook.Object, ImmutableDictionary<string, object>.Empty));
 
             apiHook.Verify(x => x.Before(
                 It.IsAny<HookContext<bool>>(), It.IsAny<IReadOnlyDictionary<string, object>>()), Times.Once);
@@ -173,19 +175,19 @@ public async Task Evaluation_Context_Must_Be_Mutable_Before_Hook()
                 FlagValueType.Boolean, new ClientMetadata("test", "1.0.0"), new Metadata(NoOpProvider.NoOpProviderName),
                 evaluationContext);
 
-            hook1.Setup(x => x.Before(It.IsAny<HookContext<It.IsAnyType>>(), It.IsAny<Dictionary<string, object>>()))
+            hook1.Setup(x => x.Before(It.IsAny<HookContext<It.IsAnyType>>(), It.IsAny<ImmutableDictionary<string, object>>()))
                 .ReturnsAsync(evaluationContext);
 
             hook2.Setup(x =>
-                    x.Before(hookContext, It.IsAny<Dictionary<string, object>>()))
+                    x.Before(hookContext, It.IsAny<ImmutableDictionary<string, object>>()))
                 .ReturnsAsync(evaluationContext);
 
             var client = OpenFeature.Instance.GetClient("test", "1.0.0");
             await client.GetBooleanValue("test", false, EvaluationContext.Empty,
-                new FlagEvaluationOptions(new[] { hook1.Object, hook2.Object }, new Dictionary<string, object>()));
+                new FlagEvaluationOptions(ImmutableList.Create(hook1.Object, hook2.Object), ImmutableDictionary<string, object>.Empty));
 
-            hook1.Verify(x => x.Before(It.IsAny<HookContext<It.IsAnyType>>(), It.IsAny<Dictionary<string, object>>()), Times.Once);
-            hook2.Verify(x => x.Before(It.Is<HookContext<bool>>(a => a.EvaluationContext.GetValue("test").AsString == "test"), It.IsAny<Dictionary<string, object>>()), Times.Once);
+            hook1.Verify(x => x.Before(It.IsAny<HookContext<It.IsAnyType>>(), It.IsAny<ImmutableDictionary<string, object>>()), Times.Once);
+            hook2.Verify(x => x.Before(It.Is<HookContext<bool>>(a => a.EvaluationContext.GetValue("test").AsString == "test"), It.IsAny<ImmutableDictionary<string, object>>()), Times.Once);
         }
 
         [Fact]
@@ -232,7 +234,7 @@ public async Task Evaluation_Context_Must_Be_Merged_In_Correct_Order()
                 .Returns(new Metadata(null));
 
             provider.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             provider.Setup(x => x.ResolveBooleanValue(It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<EvaluationContext>()))
             .ReturnsAsync(new ResolutionDetails<bool>("test", true));
@@ -240,12 +242,12 @@ public async Task Evaluation_Context_Must_Be_Merged_In_Correct_Order()
             OpenFeature.Instance.SetProvider(provider.Object);
 
             var hook = new Mock<Hook>(MockBehavior.Strict);
-            hook.Setup(x => x.Before(It.IsAny<HookContext<It.IsAnyType>>(), It.IsAny<Dictionary<string, object>>()))
+            hook.Setup(x => x.Before(It.IsAny<HookContext<It.IsAnyType>>(), It.IsAny<ImmutableDictionary<string, object>>()))
                 .ReturnsAsync(hookContext);
 
 
             var client = OpenFeature.Instance.GetClient("test", "1.0.0", null, clientContext);
-            await client.GetBooleanValue("test", false, invocationContext, new FlagEvaluationOptions(new[] { hook.Object }, new Dictionary<string, object>()));
+            await client.GetBooleanValue("test", false, invocationContext, new FlagEvaluationOptions(ImmutableList.Create(hook.Object), ImmutableDictionary<string, object>.Empty));
 
             // after proper merging, all properties should equal true
             provider.Verify(x => x.ResolveBooleanValue(It.IsAny<string>(), It.IsAny<bool>(), It.Is<EvaluationContext>(y =>
@@ -307,7 +309,7 @@ public async Task Hook_Should_Execute_In_Correct_Order()
                 .Returns(new Metadata(null));
 
             featureProvider.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             hook.InSequence(sequence).Setup(x =>
                     x.Before(It.IsAny<HookContext<It.IsAnyType>>(), It.IsAny<Dictionary<string, object>>()))
@@ -351,10 +353,10 @@ public async Task Register_Hooks_Should_Be_Available_At_All_Levels()
             var client = OpenFeature.Instance.GetClient();
             client.AddHooks(hook2.Object);
             await client.GetBooleanValue("test", false, null,
-                new FlagEvaluationOptions(hook3.Object, new Dictionary<string, object>()));
+                new FlagEvaluationOptions(hook3.Object, ImmutableDictionary<string, object>.Empty));
 
-            OpenFeature.Instance.GetHooks().Count.Should().Be(1);
-            client.GetHooks().Count.Should().Be(1);
+            Assert.Single(OpenFeature.Instance.GetHooks());
+            client.GetHooks().Count().Should().Be(1);
             testProvider.GetProviderHooks().Count.Should().Be(1);
         }
 
@@ -372,7 +374,7 @@ public async Task Finally_Hook_Should_Be_Executed_Even_If_Abnormal_Termination()
                 .Returns(new Metadata(null));
 
             featureProvider.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             hook1.InSequence(sequence).Setup(x =>
                     x.Before(It.IsAny<HookContext<It.IsAnyType>>(), null))
@@ -405,7 +407,7 @@ public async Task Finally_Hook_Should_Be_Executed_Even_If_Abnormal_Termination()
             OpenFeature.Instance.SetProvider(featureProvider.Object);
             var client = OpenFeature.Instance.GetClient();
             client.AddHooks(new[] { hook1.Object, hook2.Object });
-            client.GetHooks().Count.Should().Be(2);
+            client.GetHooks().Count().Should().Be(2);
 
             await client.GetBooleanValue("test", false);
 
@@ -431,7 +433,7 @@ public async Task Error_Hook_Should_Be_Executed_Even_If_Abnormal_Termination()
             featureProvider1.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(null));
             featureProvider1.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             hook1.InSequence(sequence).Setup(x =>
                     x.Before(It.IsAny<HookContext<It.IsAnyType>>(), null))
@@ -478,7 +480,7 @@ public async Task Error_Occurs_During_Before_After_Evaluation_Should_Not_Invoke_
             featureProvider.Setup(x => x.GetMetadata())
                 .Returns(new Metadata(null));
             featureProvider.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             hook1.InSequence(sequence).Setup(x =>
                     x.Before(It.IsAny<HookContext<It.IsAnyType>>(), It.IsAny<Dictionary<string, object>>()))
@@ -518,7 +520,7 @@ public async Task Hook_Hints_May_Be_Optional()
                 .Returns(new Metadata(null));
 
             featureProvider.Setup(x => x.GetProviderHooks())
-                .Returns(Array.Empty<Hook>());
+                .Returns(ImmutableList<Hook>.Empty);
 
             hook.InSequence(sequence)
                 .Setup(x => x.Before(It.IsAny<HookContext<It.IsAnyType>>(), defaultEmptyHookHints))
diff --git a/test/OpenFeatureSDK.Tests/OpenFeatureTests.cs b/test/OpenFeatureSDK.Tests/OpenFeatureTests.cs
index 5f9a778b..8a96e84b 100644
--- a/test/OpenFeatureSDK.Tests/OpenFeatureTests.cs
+++ b/test/OpenFeatureSDK.Tests/OpenFeatureTests.cs
@@ -1,3 +1,4 @@
+using System.Linq;
 using FluentAssertions;
 using Moq;
 using OpenFeatureSDK.Constant;
@@ -34,18 +35,18 @@ public void OpenFeature_Should_Add_Hooks()
             openFeature.AddHooks(hook1);
 
             openFeature.GetHooks().Should().Contain(hook1);
-            openFeature.GetHooks().Count.Should().Be(1);
+            Assert.Single(openFeature.GetHooks());
 
             openFeature.AddHooks(hook2);
             openFeature.GetHooks().Should().ContainInOrder(hook1, hook2);
-            openFeature.GetHooks().Count.Should().Be(2);
+            openFeature.GetHooks().Count().Should().Be(2);
 
             openFeature.AddHooks(new[] { hook3, hook4 });
             openFeature.GetHooks().Should().ContainInOrder(hook1, hook2, hook3, hook4);
-            openFeature.GetHooks().Count.Should().Be(4);
+            openFeature.GetHooks().Count().Should().Be(4);
 
             openFeature.ClearHooks();
-            openFeature.GetHooks().Count.Should().Be(0);
+            Assert.Empty(openFeature.GetHooks());
         }
 
         [Fact]
diff --git a/test/OpenFeatureSDK.Tests/TestImplementations.cs b/test/OpenFeatureSDK.Tests/TestImplementations.cs
index 4236077c..2da88c7b 100644
--- a/test/OpenFeatureSDK.Tests/TestImplementations.cs
+++ b/test/OpenFeatureSDK.Tests/TestImplementations.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Threading.Tasks;
 using OpenFeatureSDK.Model;
 
@@ -39,7 +40,7 @@ public class TestProvider : FeatureProvider
 
         public void AddHook(Hook hook) => this._hooks.Add(hook);
 
-        public override IReadOnlyList<Hook> GetProviderHooks() => this._hooks.AsReadOnly();
+        public override IImmutableList<Hook> GetProviderHooks() => this._hooks.ToImmutableList();
 
         public override Metadata GetMetadata()
         {