ASP.NET Core SignalR服务端多库Hub共享单一连接是否可行？

假设有多个类库项目L1、L2等，每个类库提供特定功能，创建Web应用时会引用这些类库并编写粘合逻辑。每个类库都暴露了自己的SignalR Hub：

L1类库的Hub：

public class L1_Hub : Hub
{
    public string Concat(string s1, string s2)
    {
        return s1 + s2;
    }
}

L2类库的Hub：

public class L2_Hub : Hub
{
    public double Calc(double a, double b)
    {
        return a + b;
    }
}

直接将两个Hub映射到同一路径会触发SignalR歧义报错：

app.MapHub<L1_Hub>("/hub");
app.MapHub<L2_Hub>("/hub");

以下是几种可行的解决方案：

方案一：创建聚合Hub作为统一入口 #

编写一个主Hub，注入各个类库的Hub实例，暴露对应方法并转发调用，只将这个主Hub映射到目标路径。

实现代码 #

主Hub定义：

public class MainHub : Hub
{
    private readonly L1_Hub _l1Hub;
    private readonly L2_Hub _l2Hub;

    // 确保类库Hub的依赖能被主应用DI容器解析
    public MainHub(L1_Hub l1Hub, L2_Hub l2Hub)
    {
        _l1Hub = l1Hub;
        _l2Hub = l2Hub;
        // 手动传递当前连接上下文给类库Hub
        _l1Hub.Context = Context;
        _l2Hub.Context = Context;
        _l1Hub.Clients = Clients;
        _l2Hub.Clients = Clients;
        _l1Hub.Groups = Groups;
        _l2Hub.Groups = Groups;
    }

    // 转发到L1_Hub的Concat方法
    public string Concat(string s1, string s2)
    {
        return _l1Hub.Concat(s1, s2);
    }

    // 转发到L2_Hub的Calc方法
    public double Calc(double a, double b)
    {
        return _l2Hub.Calc(a, b);
    }
}

映射主Hub：

app.MapHub<MainHub>("/hub");

优缺点 #

• 优点：实现简单，逻辑清晰，主应用完全控制入口，无需修改类库代码。
• 缺点：类库Hub新增方法时，需要手动在主Hub中添加对应的转发方法。

方案二：自定义HubDispatcher实现动态路由 #

通过自定义SignalR的HubDispatcher，拦截方法调用并根据方法名路由到对应的类库Hub，无需手动维护转发逻辑。

实现代码 #

自定义Dispatcher：

public class MultiHubDispatcher : HubDispatcher<Hub>
{
    private readonly IServiceProvider _serviceProvider;
    // 维护方法名到对应Hub类型的映射
    private readonly Dictionary<string, Type> _methodHubMap = new()
    {
        {"Concat", typeof(L1_Hub)},
        {"Calc", typeof(L2_Hub)}
    };

    public MultiHubDispatcher(IServiceProvider serviceProvider, HubOptions options, ILoggerFactory loggerFactory) 
        : base(options, loggerFactory)
    {
        _serviceProvider = serviceProvider;
    }

    protected override async Task OnReceivedAsync(HubLifetimeContext context, string methodName, string? invocationId, ReadOnlyMemory<byte>[] arguments)
    {
        if (_methodHubMap.TryGetValue(methodName, out var hubType))
        {
            using var scope = _serviceProvider.CreateScope();
            // 从DI容器获取类库Hub实例
            var hub = (Hub)scope.ServiceProvider.GetRequiredService(hubType);
            // 传递当前连接上下文
            hub.Context = context.Context;
            hub.Clients = context.Clients;
            hub.Groups = context.Groups;

            // 解析方法参数并调用
            var method = hubType.GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance);
            if (method != null)
            {
                var parameters = method.GetParameters();
                var parsedArgs = new object[parameters.Length];
                for (int i = 0; i < parameters.Length; i++)
                {
                    parsedArgs[i] = JsonSerializer.Deserialize(arguments[i].Span, parameters[i].ParameterType, Options.JsonSerializerOptions)!;
                }

                var result = method.Invoke(hub, parsedArgs);
                if (result is Task task) await task;

                // 返回调用结果给客户端（如果有invocationId）
                if (!string.IsNullOrEmpty(invocationId))
                {
                    var returnValue = method.ReturnType != typeof(Task) ? result : null;
                    await context.Clients.Caller.SendAsync(invocationId, returnValue);
                }
            }
        }
        else
        {
            // 处理未匹配的方法，调用默认逻辑
            await base.OnReceivedAsync(context, methodName, invocationId, arguments);
        }
    }
}

注册服务并映射：

builder.Services.AddSignalR(options =>
{
    options.Hubs.Add(typeof(Hub), new HubOptions());
})
.AddHubDispatcher<MultiHubDispatcher>();

// 映射到统一路径
app.MapHub<Hub>("/hub");

优缺点 #

• 优点：无需手动维护转发方法，类库Hub新增方法只需更新映射字典即可。
• 缺点：需要处理参数反序列化、返回值传递等底层细节，实现复杂度较高，对SignalR底层逻辑有一定要求。

方案三：结合自定义特性与路由约定（ASP.NET Core 7+） #

如果使用ASP.NET Core 7及以上版本，可以自定义路由约定，通过特性标记类库Hub的方法，实现自动路由。

实现步骤 #

1. 定义自定义特性，标记方法所属的Hub：

[AttributeUsage(AttributeTargets.Method)]
public class MapToHubAttribute : Attribute
{
    public Type HubType { get; }
    public MapToHubAttribute(Type hubType)
    {
        HubType = hubType;
    }
}

2. 在类库Hub的方法上添加特性：

public class L1_Hub : Hub
{
    [MapToHub(typeof(L1_Hub))]
    public string Concat(string s1, string s2)
    {
        return s1 + s2;
    }
}

public class L2_Hub : Hub
{
    [MapToHub(typeof(L2_Hub))]
    public double Calc(double a, double b)
    {
        return a + b;
    }
}

3. 自定义HubDispatcher，扫描特性并构建方法-Hub映射（逻辑类似方案二，只是映射字典从特性中自动生成，而非硬编码）。

优缺点 #

• 优点：灵活性高，类库可以自主标记方法所属Hub，主应用只需维护Dispatcher逻辑。
• 缺点：需要类库配合添加特性，实现复杂度与方案二相当。

内容的提问来源于stack exchange，提问作者Mario Vernari