tests and code style

KSemenenko · KSemenenko · commit 2d9fb7b9bcfb · 2025-10-31T22:02:07.000+01:00
diff --git a/ManagedCode.Orleans.SignalR.Core/Helpers/Logs.cs b/ManagedCode.Orleans.SignalR.Core/Helpers/Logs.cs
@@ -15,58 +15,58 @@ public static partial class Logs
     public static partial void Ping(ILogger logger, string grainType, string grainId);
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} AddConnection `{connectionId}`")]
     public static partial void AddConnection(ILogger logger, string grainType, string grainId, string connectionId);
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} RemoveConnection `{connectionId}`")]
     public static partial void RemoveConnection(ILogger logger, string grainType, string grainId, string connectionId);
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToAll")]
     public static partial void SendToAll(ILogger logger, string grainType, string grainId);    
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToAllExcept")]
     public static partial void SendToAllExcept(ILogger logger, string grainType, string grainId, string[] expectedConnectionIds);
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToConnection")]
     public static partial void SendToConnection(ILogger logger, string grainType, string grainId, string connectionId);
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToConnections")]
     public static partial void SendToConnections(ILogger logger, string grainType, string grainId, string[] expectedConnectionIds);
     
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToGroup")]
     public static partial void SendToGroup(ILogger logger, string grainType, string grainId);
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToGroupExcept")]
     public static partial void SendToGroupExcept(ILogger logger, string grainType, string grainId, string[] expectedConnectionIds);
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} TryCompleteResult")]
     public static partial void TryCompleteResult(ILogger logger, string grainType, string grainId, string connectionId);
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} TryGetReturnType")]
     public static partial void TryGetReturnType(ILogger logger, string grainType, string grainId);
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} AddInvocation")]
     public static partial void AddInvocation(ILogger logger, string grainType, string grainId, string invocationId, string connectionId);
         
@@ -76,9 +76,9 @@ public static partial class Logs
     public static partial void RemoveInvocation(ILogger logger, string grainType, string grainId);     
     
     [LoggerMessage(
-        Level = LogLevel.Information,
+        Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToUser")]
     public static partial void SendToUser(ILogger logger, string grainType, string grainId);  
         
         
-}
+}
diff --git a/ManagedCode.Orleans.SignalR.Core/HubContext/OrleansHubClients.cs b/ManagedCode.Orleans.SignalR.Core/HubContext/OrleansHubClients.cs
@@ -3,54 +3,47 @@
 
 namespace ManagedCode.Orleans.SignalR.Core.HubContext;
 
-internal sealed class OrleansHubClients<T> : IHubClients<T>
+internal sealed class OrleansHubClients<T>(IHubClients hubClients) : IHubClients<T>
 {
-    private readonly IHubClients _hubClients;
-
-    public OrleansHubClients(IHubClients hubClients)
-    {
-        _hubClients = hubClients;
-    }
-
     public T Client(string connectionId)
     {
-        return TypedClientBuilder<T>.Build(_hubClients.Client(connectionId));
+        return TypedClientBuilder<T>.Build(hubClients.Client(connectionId));
     }
 
-    public T All => TypedClientBuilder<T>.Build(_hubClients.All);
+    public T All => TypedClientBuilder<T>.Build(hubClients.All);
 
     public T AllExcept(IReadOnlyList<string> excludedConnectionIds)
     {
-        return TypedClientBuilder<T>.Build(_hubClients.AllExcept(excludedConnectionIds));
+        return TypedClientBuilder<T>.Build(hubClients.AllExcept(excludedConnectionIds));
     }
 
     public T Group(string groupName)
     {
-        return TypedClientBuilder<T>.Build(_hubClients.Group(groupName));
+        return TypedClientBuilder<T>.Build(hubClients.Group(groupName));
     }
 
     public T GroupExcept(string groupName, IReadOnlyList<string> excludedConnectionIds)
     {
-        return TypedClientBuilder<T>.Build(_hubClients.GroupExcept(groupName, excludedConnectionIds));
+        return TypedClientBuilder<T>.Build(hubClients.GroupExcept(groupName, excludedConnectionIds));
     }
 
     public T Clients(IReadOnlyList<string> connectionIds)
     {
-        return TypedClientBuilder<T>.Build(_hubClients.Clients(connectionIds));
+        return TypedClientBuilder<T>.Build(hubClients.Clients(connectionIds));
     }
 
     public T Groups(IReadOnlyList<string> groupNames)
     {
-        return TypedClientBuilder<T>.Build(_hubClients.Groups(groupNames));
+        return TypedClientBuilder<T>.Build(hubClients.Groups(groupNames));
     }
 
     public T User(string userId)
     {
-        return TypedClientBuilder<T>.Build(_hubClients.User(userId));
+        return TypedClientBuilder<T>.Build(hubClients.User(userId));
     }
 
     public T Users(IReadOnlyList<string> userIds)
     {
-        return TypedClientBuilder<T>.Build(_hubClients.Users(userIds));
+        return TypedClientBuilder<T>.Build(hubClients.Users(userIds));
     }
 }
diff --git a/ManagedCode.Orleans.SignalR.Core/HubContext/OrleansHubContext.cs b/ManagedCode.Orleans.SignalR.Core/HubContext/OrleansHubContext.cs
@@ -5,21 +5,15 @@ namespace ManagedCode.Orleans.SignalR.Core.HubContext;
 /// <summary>
 ///     A context abstraction for a hub.
 /// </summary>
-public class OrleansHubContext<THub, TClient> : IOrleansHubContext<THub, TClient> where THub : Hub
+public class OrleansHubContext<THub, TClient>(IHubContext<THub> context) : IOrleansHubContext<THub, TClient> where THub : Hub
 {
-    public OrleansHubContext(IHubContext<THub> context)
-    {
-        Clients = new OrleansHubClients<TClient>(context.Clients);
-        Groups = context.Groups;
-    }
-
     /// <summary>
     ///     Gets a <see cref="IHubClients" /> that can be used to invoke methods on clients connected to the hub.
     /// </summary>
-    public IHubClients<TClient> Clients { get; }
+    public IHubClients<TClient> Clients { get; } = new OrleansHubClients<TClient>(context.Clients);
 
     /// <summary>
     ///     Gets a <see cref="IGroupManager" /> that can be used to add and remove connections to named groups.
     /// </summary>
-    public IGroupManager Groups { get; }
+    public IGroupManager Groups { get; } = context.Groups;
 }
diff --git a/ManagedCode.Orleans.SignalR.Core/HubContext/TypedClientBuilder.cs b/ManagedCode.Orleans.SignalR.Core/HubContext/TypedClientBuilder.cs
@@ -14,14 +14,14 @@ internal static class TypedClientBuilder<T>
     private const string ClientModuleName = "Microsoft.AspNetCore.SignalR.TypedClientBuilder";
 
     // There is one static instance of _builder per T
-    private static readonly Lazy<Func<IClientProxy, T>> _builder = new(() => GenerateClientBuilder());
+    private static readonly Lazy<Func<IClientProxy, T>> _builder = new(GenerateClientBuilder);
 
     private static readonly PropertyInfo CancellationTokenNoneProperty =
         typeof(CancellationToken).GetProperty("None", BindingFlags.Public | BindingFlags.Static)!;
 
     private static readonly ConstructorInfo ObjectConstructor = typeof(object).GetConstructors().Single();
 
-    private static readonly Type[] ParameterTypes = { typeof(IClientProxy) };
+    private static readonly Type[] ParameterTypes = [typeof(IClientProxy)];
 
     public static T Build(IClientProxy proxy)
     {
diff --git a/ManagedCode.Orleans.SignalR.Core/Interfaces/ISignalRConnectionCoordinatorGrain.cs b/ManagedCode.Orleans.SignalR.Core/Interfaces/ISignalRConnectionCoordinatorGrain.cs
@@ -24,5 +24,6 @@ public interface ISignalRConnectionCoordinatorGrain : IGrainWithStringKey
     [OneWay]
     Task SendToConnections(HubMessage message, string[] connectionIds);
 
+    [OneWay]
     Task NotifyConnectionRemoved(string connectionId);
 }
diff --git a/ManagedCode.Orleans.SignalR.Core/Interfaces/ISignalRConnectionHeartbeatGrain.cs b/ManagedCode.Orleans.SignalR.Core/Interfaces/ISignalRConnectionHeartbeatGrain.cs
@@ -1,11 +1,14 @@
 using System.Threading.Tasks;
 using ManagedCode.Orleans.SignalR.Core.Models;
 using Orleans;
+using Orleans.Concurrency;
 
 namespace ManagedCode.Orleans.SignalR.Core.Interfaces;
 
 public interface ISignalRConnectionHeartbeatGrain : IGrainWithStringKey
 {
     Task Start(ConnectionHeartbeatRegistration registration);
+    
+    [OneWay]
     Task Stop();
 }
diff --git a/ManagedCode.Orleans.SignalR.Core/Interfaces/ISignalRGroupCoordinatorGrain.cs b/ManagedCode.Orleans.SignalR.Core/Interfaces/ISignalRGroupCoordinatorGrain.cs
@@ -22,9 +22,12 @@ public interface ISignalRGroupCoordinatorGrain : IGrainWithStringKey
     [OneWay]
     Task SendToGroups(string[] groupNames, HubMessage message);
     
+    [OneWay]
     Task AddConnectionToGroup(string groupName, string connectionId, ISignalRObserver observer);
     
+    [OneWay]
     Task RemoveConnectionFromGroup(string groupName, string connectionId, ISignalRObserver observer);
 
+    [OneWay]
     Task NotifyGroupRemoved(string groupName);
 }
diff --git a/ManagedCode.Orleans.SignalR.Core/Interfaces/ISignalRGroupPartitionGrain.cs b/ManagedCode.Orleans.SignalR.Core/Interfaces/ISignalRGroupPartitionGrain.cs
@@ -13,12 +13,15 @@ public interface ISignalRGroupPartitionGrain : IGrainWithIntegerKey, IObserverCo
     [OneWay]
     Task SendToGroupsExcept(HubMessage message, string[] groupNames, string[] excludedConnectionIds);
     
+    [OneWay]
     Task AddConnectionToGroup(string groupName, string connectionId, ISignalRObserver observer);
     
+    [OneWay]
     Task RemoveConnectionFromGroup(string groupName, string connectionId, ISignalRObserver observer);
 
     [ReadOnly]
     Task<bool> HasConnection(string connectionId);
 
+    [OneWay]
     Task EnsureInitialized(string hubKey);
 }
diff --git a/ManagedCode.Orleans.SignalR.Core/SignalR/NameHelperGenerator.cs b/ManagedCode.Orleans.SignalR.Core/SignalR/NameHelperGenerator.cs
@@ -91,7 +91,7 @@ public static ISignalRConnectionHeartbeatGrain GetConnectionHeartbeatGrain(IGrai
 
     public static string CleanString(string input)
     {
-        var builder = new System.Text.StringBuilder();
+        var builder = new StringBuilder();
         foreach (char c in input)
         {
             if (char.IsLetterOrDigit(c) || c == '-' || c == ':' || c == '.')
diff --git a/ManagedCode.Orleans.SignalR.Core/SignalR/Observers/SignalRObserver.cs b/ManagedCode.Orleans.SignalR.Core/SignalR/Observers/SignalRObserver.cs
@@ -5,14 +5,9 @@
 
 namespace ManagedCode.Orleans.SignalR.Core.SignalR.Observers;
 
-public class SignalRObserver : ISignalRObserver, IDisposable
+public class SignalRObserver(Func<HubMessage, Task> onNextAction) : ISignalRObserver, IDisposable
 {
-    private Func<HubMessage, Task>? _onNextAction;
-
-    public SignalRObserver(Func<HubMessage, Task> onNextAction)
-    {
-        _onNextAction = onNextAction;
-    }
+    private Func<HubMessage, Task>? _onNextAction = onNextAction;
 
     public void Dispose()
     {
diff --git a/ManagedCode.Orleans.SignalR.Core/SignalR/Observers/Subscription.cs b/ManagedCode.Orleans.SignalR.Core/SignalR/Observers/Subscription.cs
@@ -4,17 +4,11 @@
 
 namespace ManagedCode.Orleans.SignalR.Core.SignalR.Observers;
 
-public class Subscription : IDisposable
+public class Subscription(SignalRObserver observer) : IDisposable
 {
     private readonly HashSet<IObserverConnectionManager> _grains = new();
-    private readonly SignalRObserver _observer;
     private bool _disposed;
 
-    public Subscription(SignalRObserver observer)
-    {
-        _observer = observer;
-    }
-    
     ~Subscription()
     {
         Dispose();
@@ -32,7 +26,7 @@ public void Dispose()
         }
 
         _disposed = true;
-        _observer?.Dispose();
+        observer?.Dispose();
         _grains?.Clear();
         Reference = null!;
     }
@@ -54,6 +48,6 @@ public void SetReference(ISignalRObserver reference)
 
     public SignalRObserver GetObserver()
     {
-        return _observer;
+        return observer;
     }
 }
diff --git a/ManagedCode.Orleans.SignalR.Tests/Cluster/Grains/TestGrain.cs b/ManagedCode.Orleans.SignalR.Tests/Cluster/Grains/TestGrain.cs
@@ -2,9 +2,11 @@
 using ManagedCode.Orleans.SignalR.Tests.Cluster.Grains.Interfaces;
 using ManagedCode.Orleans.SignalR.Tests.TestApp.Hubs;
 using Microsoft.AspNetCore.SignalR;
+using Orleans.Concurrency;
 
 namespace ManagedCode.Orleans.SignalR.Tests.Cluster.Grains;
 
+[Reentrant]
 public class TestGrain : Grain, ITestGrain
 {
     private readonly IHubContext<InterfaceTestHub> _hubContext;
diff --git a/ManagedCode.Orleans.SignalR.Tests/CoordinatorScalingTests.cs b/ManagedCode.Orleans.SignalR.Tests/CoordinatorScalingTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
 using Shouldly;
@@ -48,7 +49,7 @@ public async Task ConnectionCoordinator_Scales_With_Connection_Load()
             await coordinator.NotifyConnectionRemoved(id);
         }
 
-        var reset = await coordinator.GetPartitionCount();
+        var reset = await WaitForPartitionCountAsync(() => coordinator.GetPartitionCount(), baseline, _output);
         reset.ShouldBe(baseline);
     }
 
@@ -78,7 +79,28 @@ public async Task GroupCoordinator_Scales_With_Group_Load()
             await coordinator.NotifyGroupRemoved(group);
         }
 
-        var reset = await coordinator.GetPartitionCount();
+        var reset = await WaitForPartitionCountAsync(() => coordinator.GetPartitionCount(), baseline, _output);
         reset.ShouldBe(baseline);
     }
+
+    private static async Task<int> WaitForPartitionCountAsync(Func<Task<int>> accessor, int expected, ITestOutputHelper output)
+    {
+        var timeout = TimeSpan.FromSeconds(5);
+        var poll = TimeSpan.FromMilliseconds(100);
+        var stopwatch = Stopwatch.StartNew();
+        int current = await accessor();
+
+        while (current != expected && stopwatch.Elapsed < timeout)
+        {
+            await Task.Delay(poll);
+            current = await accessor();
+        }
+
+        if (current != expected)
+        {
+            output.WriteLine($"Partition count not reset to {expected} within {timeout.TotalSeconds}s. Current={current}.");
+        }
+
+        return current;
+    }
 }
diff --git a/ManagedCode.Orleans.SignalR.Tests/TestApp/TestWebApplication.cs b/ManagedCode.Orleans.SignalR.Tests/TestApp/TestWebApplication.cs
@@ -91,7 +91,7 @@ public HubConnection CreateSignalRClient(string hubPath, Action<HubConnectionBui
         builder.WithAutomaticReconnect();
         configure?.Invoke(builder);
 
-        return builder.WithUrl(new Uri(baseUri, hubPath), HttpTransportType.LongPolling, options =>
+        return builder.WithUrl(new Uri(baseUri, hubPath), options =>
         {
             configureConnection?.Invoke(options);
             options.HttpMessageHandlerFactory = _ => Server.CreateHandler();
diff --git a/README.md b/README.md
@@ -206,7 +206,7 @@ services.AddSignalR()
 
 - Request the `IOrleansHubContext<THub>` or `IOrleansHubContext<THub, TClient>` via DI in any grain.
 - You can still inject the classic `IHubContext<THub>` if you prefer manual access to `Clients`, `Groups`, etc.
-- Client invocations (`Clients.Client(connectionId).InvokeAsync(...)`) are supported. Wrap them in `Task.Run` or use asynchronous continuations to avoid blocking the Orleans scheduler.
+- Client invocations (`Clients.Client(connectionId).InvokeAsync(...)`) are supported. Run them via `Task.Run` (or another scheduler hop) so the Orleans scheduler is never blocked.
 
 ```csharp
 public class LiveScoreGrain : Grain, ILiveScoreGrain

Original file line number	Diff line number	Diff line change
`@@ -3,54 +3,47 @@`
`3`	`3`
`4`	`4`	`namespace ManagedCode.Orleans.SignalR.Core.HubContext;`
`5`	`5`
`6`		`-internal sealed class OrleansHubClients<T> : IHubClients<T>`
	`6`	`+internal sealed class OrleansHubClients<T>(IHubClients hubClients) : IHubClients<T>`
`7`	`7`	`{`
`8`		`- private readonly IHubClients _hubClients;`
`9`		`-`
`10`		`- public OrleansHubClients(IHubClients hubClients)`
`11`		`- {`
`12`		`- _hubClients = hubClients;`
`13`		`- }`
`14`		`-`
`15`	`8`	`public T Client(string connectionId)`
`16`	`9`	`{`
`17`		`- return TypedClientBuilder<T>.Build(_hubClients.Client(connectionId));`
	`10`	`+ return TypedClientBuilder<T>.Build(hubClients.Client(connectionId));`
`18`	`11`	`}`
`19`	`12`
`20`		`- public T All => TypedClientBuilder<T>.Build(_hubClients.All);`
	`13`	`+ public T All => TypedClientBuilder<T>.Build(hubClients.All);`
`21`	`14`
`22`	`15`	`public T AllExcept(IReadOnlyList<string> excludedConnectionIds)`
`23`	`16`	`{`
`24`		`- return TypedClientBuilder<T>.Build(_hubClients.AllExcept(excludedConnectionIds));`
	`17`	`+ return TypedClientBuilder<T>.Build(hubClients.AllExcept(excludedConnectionIds));`
`25`	`18`	`}`
`26`	`19`
`27`	`20`	`public T Group(string groupName)`
`28`	`21`	`{`
`29`		`- return TypedClientBuilder<T>.Build(_hubClients.Group(groupName));`
	`22`	`+ return TypedClientBuilder<T>.Build(hubClients.Group(groupName));`
`30`	`23`	`}`
`31`	`24`
`32`	`25`	`public T GroupExcept(string groupName, IReadOnlyList<string> excludedConnectionIds)`
`33`	`26`	`{`
`34`		`- return TypedClientBuilder<T>.Build(_hubClients.GroupExcept(groupName, excludedConnectionIds));`
	`27`	`+ return TypedClientBuilder<T>.Build(hubClients.GroupExcept(groupName, excludedConnectionIds));`
`35`	`28`	`}`
`36`	`29`
`37`	`30`	`public T Clients(IReadOnlyList<string> connectionIds)`
`38`	`31`	`{`
`39`		`- return TypedClientBuilder<T>.Build(_hubClients.Clients(connectionIds));`
	`32`	`+ return TypedClientBuilder<T>.Build(hubClients.Clients(connectionIds));`
`40`	`33`	`}`
`41`	`34`
`42`	`35`	`public T Groups(IReadOnlyList<string> groupNames)`
`43`	`36`	`{`
`44`		`- return TypedClientBuilder<T>.Build(_hubClients.Groups(groupNames));`
	`37`	`+ return TypedClientBuilder<T>.Build(hubClients.Groups(groupNames));`
`45`	`38`	`}`
`46`	`39`
`47`	`40`	`public T User(string userId)`
`48`	`41`	`{`
`49`		`- return TypedClientBuilder<T>.Build(_hubClients.User(userId));`
	`42`	`+ return TypedClientBuilder<T>.Build(hubClients.User(userId));`
`50`	`43`	`}`
`51`	`44`
`52`	`45`	`public T Users(IReadOnlyList<string> userIds)`
`53`	`46`	`{`
`54`		`- return TypedClientBuilder<T>.Build(_hubClients.Users(userIds));`
	`47`	`+ return TypedClientBuilder<T>.Build(hubClients.Users(userIds));`
`55`	`48`	`}`
`56`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,5 +24,6 @@ public interface ISignalRConnectionCoordinatorGrain : IGrainWithStringKey`
`24`	`24`	`[OneWay]`
`25`	`25`	`Task SendToConnections(HubMessage message, string[] connectionIds);`
`26`	`26`
	`27`	`+ [OneWay]`
`27`	`28`	`Task NotifyConnectionRemoved(string connectionId);`
`28`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,14 @@`
`1`	`1`	`using System.Threading.Tasks;`
`2`	`2`	`using ManagedCode.Orleans.SignalR.Core.Models;`
`3`	`3`	`using Orleans;`
	`4`	`+using Orleans.Concurrency;`
`4`	`5`
`5`	`6`	`namespace ManagedCode.Orleans.SignalR.Core.Interfaces;`
`6`	`7`
`7`	`8`	`public interface ISignalRConnectionHeartbeatGrain : IGrainWithStringKey`
`8`	`9`	`{`
`9`	`10`	`Task Start(ConnectionHeartbeatRegistration registration);`
	`11`	`+`
	`12`	`+ [OneWay]`
`10`	`13`	`Task Stop();`
`11`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ public static ISignalRConnectionHeartbeatGrain GetConnectionHeartbeatGrain(IGrai`
`91`	`91`
`92`	`92`	`public static string CleanString(string input)`
`93`	`93`	`{`
`94`		`- var builder = new System.Text.StringBuilder();`
	`94`	`+ var builder = new StringBuilder();`
`95`	`95`	`foreach (char c in input)`
`96`	`96`	`{`
`97`	`97`	`if (char.IsLetterOrDigit(c) \|\| c == '-' \|\| c == ':' \|\| c == '.')`
Original file line number	Diff line number	Diff line change
`@@ -5,14 +5,9 @@`
`5`	`5`
`6`	`6`	`namespace ManagedCode.Orleans.SignalR.Core.SignalR.Observers;`
`7`	`7`
`8`		`-public class SignalRObserver : ISignalRObserver, IDisposable`
	`8`	`+public class SignalRObserver(Func<HubMessage, Task> onNextAction) : ISignalRObserver, IDisposable`
`9`	`9`	`{`
`10`		`- private Func<HubMessage, Task>? _onNextAction;`
`11`		`-`
`12`		`- public SignalRObserver(Func<HubMessage, Task> onNextAction)`
`13`		`- {`
`14`		`- _onNextAction = onNextAction;`
`15`		`- }`
	`10`	`+ private Func<HubMessage, Task>? _onNextAction = onNextAction;`
`16`	`11`
`17`	`12`	`public void Dispose()`
`18`	`13`	`{`