Is there a way to avoid using magic strings with the HubConnection class

Question

I have a strongly typed Hub on the server:

public Foo : Hub<Bar> {}

Bar is supposed to be an interface including methods available on the client side. But that solves only half of the problem (the server half). On the client side, I still have to use magic strings to define handlers for calls to the methods of Bar:

 hubConnection.On<int>("MethodInsideBar", param => DoSomething(param));

Is there a way to avoid doing this ? Shouldn't there be a way to implement Bar client side and link the calls from the server to that implementation ?

score 1 · Answer 1 · answered Oct 18 '21 at 13:16

You can use the SignalR.Strong NuGet

Sample Code:
Foo.cs

public interface IBar
{
    Task MethodInsideBar(int n);
}
public class Foo : Hub<IBar> {}

Client.cs:

public class MySpoke : IBar
{
    public Task MethodInsideBar(int n)
    {
        // 
        return Task.CompletedTask;
    }
}

var conn = new SignalR.Client.HubConnection()
    .WithUrl("http://localhost:53353/MyHub")
    .Build();

await conn.StartAsync();

var registration = conn.RegisterSpoke<IBar>(new MySpoke())

BlazorPage.razor

@using Microsoft.AspNetCore.SignalR.Client
@using SignalR.Strong
@inject NavigationManager Nav
@implements IBar

@code {
    private HubConnection? hubConnection;

    public Task MethodInsideBar(int n)
    {
        // 
        return Task.CompletedTask;
    }

    protected override async Task OnInitializedAsync()
    {
        hubConnection = new HubConnectionBuilder()
            .WithUrl(Nav.ToAbsoluteUri("/foo"))
            .WithAutomaticReconnect()
            .Build();

        await hubConnection.StartAsync();

        hubConnection.RegisterSpoke<IBar>(this);

        await base.OnInitializedAsync();
    }
}

server.cs

public class FooBar
{
    private readonly IHubContext<Foo, IBar>? _hubContext;

    // dependency injected IHubContext
    public FooBar(IHubContext<Foo, IBar>? hubContext)
    {
        _hubContext = hubContext;
    }

    public void CallBar(int n)
    {
        _hubContext?.Clients.All.MethodInsideBar(n);
    }
}

score 0 · Accepted Answer · answered Feb 10 '21 at 09:07

On the client side, I still have to use magic strings to define handlers for calls to the methods of Bar:
hubConnection.On<int>("MethosInsideBar", param => DoSomething(param)); 
Is there a way to avoid doing this ? Shouldn't there be a way to implement Bar client side and link the calls from the server to that implementation ?

As far as I know, the Strongly typed hubs only apply to the server side, we could inject the strongly-typed HubContext in the controller, then, call the hub method. It can prevent the method name is misspelled or missing from the client.

On the client side, we still need to use the Invoke method call the public methods on hubs, and define a method using the on method of the HubConnection to receive messages from the hub.

When calling the public hub methods from client, if you want to use the Strongly typed Hubs, you could inject the Strongly typed hubcontext into the controller, then use JQuery Ajax call the controller's action method, then use the Strongly typed hubs method. Refer this thread: SignalR - Call statically typed hub from Context.

Is there a way to avoid using magic strings with the HubConnection class

2 Answers2