SignalR custom dispatching in ASP.NET Core 3.1

[lorenzrox]

Some time ago I created a custom service stack that makes possible to expose a service defined as a .NET interface as a remote service using an extensible set of protocols and transports.
In order to support SignalR, the solution uses a custom HubDispatcher implementation that overrides DispatchMessageAsync that forwards the InvocationMessage to the generic dispatcher that uses IL Emit to translate the protocol message into an actual method call.
I need now to bring this service stack to ASP.NET Core 3.1 but I just realized that HubDispatcher is now internal and I cannot inject my custom dispatcher anywhere.
The only solution I see at the moment is to re-implement the whole SignalR protocol in a custom ConnectionHandler and do the job there but I'd prefer not to reinvent the wheel and do this the proper way.
Any suggestion?

[davidfowl]

This isn't a scenario we designed for so the dispatcher was made internal. Are you trying to call the dispatcher or implement your own?

[lorenzrox]

Implement my own.
I need to handle the InvocationMessages myself and dispatch them to my generic dispatcher instead of the SignalR hub.

This is what I have in 2.2:

interal sealed class ServiceHubDispatcher<TService> : HubDispatcher<Hub<TService>>
        where TService : class
{
        ...

        public override async Task OnConnectedAsync(HubConnectionContext connection)
        {
            //Create custom connection context that holds my generic dispatcher
        }

        public override Task OnDisconnectedAsync(HubConnectionContext connection, Exception exception)
        {
            //Remove and dispose custom connection context
        }

        public override Task DispatchMessageAsync(HubConnectionContext connection, HubMessage hubMessage)
        {
            switch (hubMessage)
            {
                case InvocationBindingFailureMessage bindingFailureMessage:
                    return HandleInvocationBindingFailureAsync(connection, bindingFailureMessage.InvocationId, bindingFailureMessage.Target);
                case InvocationMessage invocationMessage:
                    return HandleInvocationAsync(connection, invocationMessage);
                case PingMessage _:
                    StartClientTimeoutMethod(connection);
                    return Task.CompletedTask;
                default:
                    throw new NotSupportedException($"Received unsupported message: {hubMessage}");
            }
        }

        protected async Task HandleInvocationAsync(HubConnectionContext connection, InvocationMessage invocationMessage)
        {
            //Forward the InvocationMessage to my generic dispatcher
        }

        protected Task HandleInvocationBindingFailureAsync(HubConnectionContext connection, string invocationId, string target)
        {
            return connection.WriteAsync(CompletionMessage.WithError(invocationId, $"Failed to invoke '{target}' due to an error on the server.")).AsTask();
        }

        ...
}

[davidfowl]

Yea this is no longer possible so you'll need to use the protocol implementation to implement your own ConnectionHandler and write a custom dispatcher. That shouldn't be too since the HubProtocol and friends are all exposed public APIs