Version 3.1.0

Author: LostBeard

SpawnDev.BlazorJS.WebWorkers.Demo/Services/UnitTestsService.cs

@@ -671,7 +671,7 @@ public async Task SharedWebWorkerTest()
         {
             if (!WebWorkerService.SharedWebWorkerSupported)
             {
-                throw new UnsupportedTestException("SharedWorker not supported by browser.");
+                throw new UnsupportedTestException("_sharedWorker not supported by browser.");
             }
 
             var thisInstanceId = JS.InstanceId;
@@ -696,7 +696,7 @@ public async Task SharedWebWorkersByName()
         {
             if (!WebWorkerService.SharedWebWorkerSupported)
             {
-                throw new UnsupportedTestException("SharedWorker not supported by browser.");
+                throw new UnsupportedTestException("_sharedWorker not supported by browser.");
             }
             // workerA1 and workerA2 will refer to the same shared worker
             // workerB is a separate worker instance
@@ -712,8 +712,8 @@ public async Task SharedWebWorkersByName()
             var valueGetWorkerA1 = await mathServiceA1.GetValueTest();
             var valueGetWorkerA2 = await mathServiceA2.GetValueTest();
             if (valueGetWorkerA1 != valueSetWorkerA1) throw new Exception("Unexpected result");
-            if (valueGetWorkerA2 != valueSetWorkerA1) throw new Exception("SharedWorker appears not shared");
-            if (valueGetWorkerB == valueSetWorkerA1) throw new Exception("SharedWorker with different name unexpectedly same as first SharedWorker");
+            if (valueGetWorkerA2 != valueSetWorkerA1) throw new Exception("_sharedWorker appears not shared");
+            if (valueGetWorkerB == valueSetWorkerA1) throw new Exception("_sharedWorker with different name unexpectedly same as first _sharedWorker");
         }
         #endregion
 

SpawnDev.BlazorJS.WebWorkers/SharedWebWorker.cs

@@ -2,26 +2,52 @@
 
 namespace SpawnDev.BlazorJS.WebWorkers
 {
+    /// <summary>
+    /// Provides a dispatcher for service calls using a shared web worker, enabling concurrent processing across
+    /// multiple browser contexts.
+    /// </summary>
+    /// <remarks>Shared web workers are only supported in environments where the 'SharedWorker' API is
+    /// available. Use the static 'Supported' property to determine if shared web workers can be utilized. The worker's
+    /// name uniquely identifies it within the application context. This class manages the lifecycle of the shared
+    /// worker and ensures proper resource cleanup by implementing IDisposable.</remarks>
     public class SharedWebWorker : ServiceCallDispatcher, IDisposable
     {
+        /// <summary>
+        /// Returns true if the SharedWorker API is supported in the current environment, allowing for the use of shared web workers. This property is initialized in the static constructor by checking if the 'SharedWorker' object is defined in the JavaScript environment. If it is undefined, it indicates that shared web workers are not supported, and the property will be set to false. This allows developers to conditionally use shared web workers based on the capabilities of the user's browser or environment.
+        /// </summary>
         public static bool Supported;
         static SharedWebWorker()
         {
             Supported = !JS.IsUndefined("SharedWorker");
         }
-        SharedWorker _shareWorker { get; set; }
+        /// <summary>
+        /// The underlying SharedWorker instance that this SharedWebWorker manages. This property provides access to the shared worker, allowing for communication and control over its lifecycle. The SharedWorker is responsible for handling concurrent processing across multiple browser contexts, and this property allows developers to interact with it directly if needed. Proper management of the shared worker is crucial for ensuring efficient resource usage and preventing memory leaks, especially when disposing of the SharedWebWorker instance.
+        /// </summary>
+        SharedWorker _sharedWorker { get; set; }
+        /// <summary>
+        /// The name of the shared worker, which is used to identify it across different browser contexts. This name is
+        /// </summary>
         public string Name { get; }
+        /// <summary>
+        /// Creates a new instance of the SharedWebWorker class, initializing it with the specified name, shared worker, and background service manager. The constructor sets up the communication channel with the shared worker and starts the message port if it is available. The shared worker is responsible for handling concurrent processing across multiple browser contexts, while the background service manager manages the services that can be called from the worker. Proper disposal of resources is handled to ensure efficient cleanup when the worker is no longer needed.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="sharedWorker"></param>
+        /// <param name="webAssemblyServices"></param>
         public SharedWebWorker(string name, SharedWorker sharedWorker, IBackgroundServiceManager webAssemblyServices) : base(webAssemblyServices, sharedWorker.Port)
         {
             Name = name;
-            _shareWorker = sharedWorker;
+            _sharedWorker = sharedWorker;
             if (_port is MessagePort port) port.Start();
         }
-
+        /// <summary>
+        /// Disposes of the resources used by the SharedWebWorker instance, including terminating the shared worker and cleaning up the message port. This method ensures that all resources are properly released when the worker is no longer needed, preventing memory leaks and ensuring efficient resource management. The disposal process includes invoking any registered disposal events and handling exceptions that may occur during termination. After disposing of the shared worker and message port, it calls the base class's Dispose method to complete the cleanup process.
+        /// </summary>
+        /// <param name="disposing"></param>
         protected override void Dispose(bool disposing)
         {
             if (IsDisposed) return;
-            _shareWorker?.Dispose();
+            _sharedWorker?.Dispose();
             _port?.Dispose();
             base.Dispose(disposing);
         }

SpawnDev.BlazorJS.WebWorkers/SpawnDev.BlazorJS.WebWorkers.csproj

@@ -4,7 +4,7 @@
 		<TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
 		<Nullable>enable</Nullable>
 		<ImplicitUsings>enable</ImplicitUsings>
-		<Version>3.0.0</Version>
+		<Version>3.1.0</Version>
 		<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
 		<EmbedAllSources>true</EmbedAllSources>
@@ -76,7 +76,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="SpawnDev.BlazorJS" Version="3.0.0" />
+		<PackageReference Include="SpawnDev.BlazorJS" Version="3.4.0" />
 	</ItemGroup>
 
 	<ItemGroup>

SpawnDev.BlazorJS.WebWorkers/WebWorkerService.cs

@@ -176,7 +176,7 @@ public WebWorkerService(IBackgroundServiceManager webAssemblyServices, BlazorJSR
             if (JS.IsBrowser)
             {
                 WebWorkerSupported = !JS.IsUndefined("Worker");
-                SharedWebWorkerSupported = !JS.IsUndefined("SharedWorker");
+                SharedWebWorkerSupported = !JS.IsUndefined("_sharedWorker");
                 ServiceWorkerSupported = !JS.IsUndefined("ServiceWorkerRegistration");
                 AppBaseUri = JS.Get<string?>("document?.baseURI") ?? JS.Get<string>("documentBaseURI");
                 var locationHref = JS.Get<string>("location.href");