fix: ArgumentNullException when creating a client with optional name (#508)

<!-- Please use this template for your pull request. -->
<!-- Please use the sections that you need and delete other sections -->

## This PR
<!-- add the description of the PR here -->

- Adds a default placeholder name that gets generated when a Client is
generated. This is inspired from the Java SDK (see
[EventSource.java](https://github.com/open-feature/java-sdk/blob/0515ad54c4f71863373eb1b7f429393923b27d90/src/main/java/dev/openfeature/sdk/EventSupport.java#L40)).
The exception is thrown when an optional client name is specified when
retrieving a client from `Api.Instance`. When no name is specified we
use a generated one.

### Related Issues
<!-- add here the GitHub issue that this PR resolves if applicable -->

Fixes #491

### Notes
<!-- any additional notes for this PR -->

### Follow-up Tasks
<!-- anything that is related to this PR but not done here should be
noted under this section -->
<!-- if there is a need for a new issue, please link it here -->

### How to test
<!-- if applicable, add testing instructions under this section -->

---------

Signed-off-by: Kyle Julian <[email protected]>
Co-authored-by: André Silva <[email protected]>

Author: kylejuliandev

src/OpenFeature/EventExecutor.cs

@@ -14,6 +14,9 @@ internal sealed partial class EventExecutor : IAsyncDisposable
     private readonly Dictionary<string, FeatureProvider> _namedProviderReferences = [];
     private readonly List<FeatureProvider> _activeSubscriptions = [];
 
+    /// placeholder for anonymous clients
+    private static Guid _defaultClientName = Guid.NewGuid();
+
     private readonly Dictionary<ProviderEventTypes, List<EventHandlerDelegate>> _apiHandlers = [];
     private readonly Dictionary<string, Dictionary<ProviderEventTypes, List<EventHandlerDelegate>>> _clientHandlers = [];
 
@@ -58,35 +61,39 @@ internal void RemoveApiLevelHandler(ProviderEventTypes type, EventHandlerDelegat
 
     internal void AddClientHandler(string client, ProviderEventTypes eventType, EventHandlerDelegate handler)
     {
+        var clientName = GetClientName(client);
+
         lock (this._lockObj)
         {
             // check if there is already a list of handlers for the given client and event type
-            if (!this._clientHandlers.TryGetValue(client, out var registry))
+            if (!this._clientHandlers.TryGetValue(clientName, out var registry))
             {
                 registry = [];
-                this._clientHandlers[client] = registry;
+                this._clientHandlers[clientName] = registry;
             }
 
-            if (!this._clientHandlers[client].TryGetValue(eventType, out var eventHandlers))
+            if (!this._clientHandlers[clientName].TryGetValue(eventType, out var eventHandlers))
             {
                 eventHandlers = [];
-                this._clientHandlers[client][eventType] = eventHandlers;
+                this._clientHandlers[clientName][eventType] = eventHandlers;
             }
 
-            this._clientHandlers[client][eventType].Add(handler);
+            this._clientHandlers[clientName][eventType].Add(handler);
 
             this.EmitOnRegistration(
-                this._namedProviderReferences.TryGetValue(client, out var clientProviderReference)
+                this._namedProviderReferences.TryGetValue(clientName, out var clientProviderReference)
                     ? clientProviderReference
                     : this._defaultProvider, eventType, handler);
         }
     }
 
     internal void RemoveClientHandler(string client, ProviderEventTypes type, EventHandlerDelegate handler)
     {
+        var clientName = GetClientName(client);
+
         lock (this._lockObj)
         {
-            if (this._clientHandlers.TryGetValue(client, out var clientEventHandlers))
+            if (this._clientHandlers.TryGetValue(clientName, out var clientEventHandlers))
             {
                 if (clientEventHandlers.TryGetValue(type, out var eventHandlers))
                 {
@@ -118,15 +125,18 @@ internal void RegisterClientFeatureProvider(string client, FeatureProvider? prov
         {
             return;
         }
+
+        var clientName = GetClientName(client);
+
         lock (this._lockObj)
         {
             FeatureProvider? oldProvider = null;
-            if (this._namedProviderReferences.TryGetValue(client, out var foundOldProvider))
+            if (this._namedProviderReferences.TryGetValue(clientName, out var foundOldProvider))
             {
                 oldProvider = foundOldProvider;
             }
 
-            this._namedProviderReferences[client] = provider;
+            this._namedProviderReferences[clientName] = provider;
 
             this.StartListeningAndShutdownOld(provider, oldProvider);
         }
@@ -303,6 +313,14 @@ private void ProcessDefaultProviderHandlers(Event e)
         }
     }
 
+    private static string GetClientName(string client)
+    {
+        if (string.IsNullOrWhiteSpace(client))
+        {
+            return _defaultClientName.ToString();
+        }
+        return client;
+    }
 
     // map events to provider status as per spec: https://openfeature.dev/specification/sections/events/#requirement-535
     private static void UpdateProviderStatus(FeatureProvider provider, ProviderEventPayload eventPayload)

test/OpenFeature.Tests/OpenFeatureClientTests.cs

@@ -597,6 +597,21 @@ public async Task PassingABlankStringAsTrackingEventName_ThrowsArgumentException
         Assert.Throws<ArgumentException>(() => client.Track(" \n "));
     }
 
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("   ")]
+    public async Task PassingBlankClientName_DoesNotThrowArgumentNullException(string? clientName)
+    {
+        var provider = new TestProvider();
+        await Api.Instance.SetProviderAsync(provider);
+        var client = Api.Instance.GetClient(clientName);
+
+        var ex = Record.Exception(() => client.AddHandler(ProviderEventTypes.ProviderReady, (args) => { }));
+
+        Assert.Null(ex);
+    }
+
     public static TheoryData<string, EvaluationContext?, EvaluationContext?, EvaluationContext?, string> GenerateMergeEvaluationContextTestData()
     {
         const string key = "key";