Avoid blocking SemaphoreSlim.Wait in BuildDatasyncOfflineOptions for browser-wasm (#574)

Use a Monitor lock for the synchronous lazy init, since SemaphoreSlim.Wait is unsupported on single-threaded browser-wasm. Adds regression tests.

Author: Atakan Ük

src/CommunityToolkit.Datasync.Client/Offline/OfflineDbContext.cs

@@ -60,7 +60,12 @@ public abstract partial class OfflineDbContext : DbContext
     /// A checker for the disposed state of this context.
     /// </summary>
     internal bool _disposedValue;
-    internal DisposableLock _optionsLock = new();
+
+    /// <summary>
+    /// Guards the lazy creation of <see cref="OfflineOptions"/>.  A monitor is used instead of a
+    /// <see cref="SemaphoreSlim"/> because blocking semaphore waits are not supported on single-threaded browser-wasm.
+    /// </summary>
+    private readonly object _optionsLock = new();
 
     /// <summary>
     /// The operations queue.  This is used to store pending requests to the datasync service.
@@ -144,15 +149,17 @@ protected OfflineDbContext(DbContextOptions options) : base(options)
     /// <returns>The offline options for the datasync operation.</returns>
     internal OfflineOptions BuildDatasyncOfflineOptions()
     {
-        using IDisposable optionsLock = this._optionsLock.AcquireLock();
-        if (OfflineOptions is null)
+        lock (this._optionsLock)
         {
-            DatasyncOfflineOptionsBuilder builder = new(QueueManager.GetSynchronizableEntityTypes());
-            OnDatasyncInitialization(builder);
-            OfflineOptions = builder.Build();
+            if (OfflineOptions is null)
+            {
+                DatasyncOfflineOptionsBuilder builder = new(QueueManager.GetSynchronizableEntityTypes());
+                OnDatasyncInitialization(builder);
+                OfflineOptions = builder.Build();
+            }
+
+            return OfflineOptions;
         }
-        
-        return OfflineOptions;
     }
 
     /// <summary>
@@ -604,7 +611,6 @@ protected virtual void Dispose(bool disposing)
         {
             if (disposing)
             {
-                this._optionsLock.Dispose();
                 base.Dispose();
             }
 

tests/CommunityToolkit.Datasync.Client.Test/Offline/OfflineDbContext_Tests.cs

@@ -5,6 +5,7 @@
 #pragma warning disable IDE0305 // Simplify collection initialization
 
 using CommunityToolkit.Datasync.Client.Offline;
+using CommunityToolkit.Datasync.Client.Offline.Models;
 using CommunityToolkit.Datasync.Client.Serialization;
 using CommunityToolkit.Datasync.Client.Test.Offline.Helpers;
 using CommunityToolkit.Datasync.TestCommon;
@@ -41,6 +42,34 @@ public void Base_Ctor_CreatesInternalApi()
     }
     #endregion
 
+    #region BuildDatasyncOfflineOptions
+    [Fact]
+    public void BuildDatasyncOfflineOptions_ReturnsSameInstance()
+    {
+        int configured = 0;
+        this.context.Configurator = _ => configured++;
+
+        OfflineOptions first = this.context.BuildDatasyncOfflineOptions();
+        OfflineOptions second = this.context.BuildDatasyncOfflineOptions();
+
+        second.Should().BeSameAs(first);
+        configured.Should().Be(1);
+    }
+
+    [Fact]
+    public async Task BuildDatasyncOfflineOptions_ConcurrentCalls_BuildOnce()
+    {
+        int configured = 0;
+        this.context.Configurator = _ => Interlocked.Increment(ref configured);
+
+        OfflineOptions[] results = await Task.WhenAll(
+            Enumerable.Range(0, 16).Select(_ => Task.Run(() => this.context.BuildDatasyncOfflineOptions())));
+
+        results.Should().OnlyContain(o => ReferenceEquals(o, results[0]));
+        configured.Should().Be(1);
+    }
+    #endregion
+
     #region PullAsync
     [Fact]
     public async Task PullAsync_List_Works_InitialSync()