如何在.NET Core应用中全局共享SignalR Hub上下文

你当前的核心矛盾是：类库中启动了独立的SignalR Host，但主项目的DI容器与该Host的容器完全隔离——主项目自行调用services.AddSignalR()注册的IHubContext属于主项目的空SignalR配置，和类库中运行的Hub实例毫无关联；不调用该方法则会抛出IHubContext未注入的错误。

以下是几种替代Simple Injector的解决方案，均可实现类库Hub上下文全局可用且尽量减少主项目修改：

方案1：让类库直接暴露关联好的HubContext #

不需要主项目配置SignalR，由类库在启动SignalR Host时保存对应的IHubContext，主项目通过类库的服务实例获取该上下文。

修改类库的SignalRService： #

public class SignalRService : ISignalRServer
{
    private IHost _host;
    private readonly ISignalRController _signalRController;
    
    // 暴露已关联类库SignalR Host的HubContext
    public IHubContext<RecordingHub, SignalRClient> HubContext { get; private set; }

    public SignalRService(ISignalRController signalRController)
    {
        _signalRController = signalRController;
    }

    public async Task Start()
    {
        _host = Host.CreateDefaultBuilder()
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.ConfigureServices(services =>
                {
                    services.AddSingleton(_signalRController);
                });
                webBuilder.UseStartup<SignalRConfiguration>();
                webBuilder.UseUrls("https://url:port");
            })
            .Build();

        // 从类库Host的服务容器中获取真实关联的HubContext
        HubContext = _host.Services.GetRequiredService<IHubContext<RecordingHub, SignalRClient>>();
        
        await _host.RunAsync();
    }

    // 建议添加优雅关闭方法
    public async Task StopAsync(CancellationToken cancellationToken = default)
    {
        if (_host != null)
        {
            await _host.StopAsync(cancellationToken);
            await _host.DisposeAsync();
        }
    }
}

主项目使用方式： #

主项目无需调用services.AddSignalR()，直接注入ISignalRServer获取可用的HubContext：

// 主项目Program.cs注册类库服务
builder.Services.AddSingleton<ISignalRServer>(sp => 
{
    var controller = sp.GetRequiredService<ISignalRController>();
    return new SignalRService(controller);
});

// 主项目中需要使用HubContext的类
public class MainAppService
{
    private readonly IHubContext<RecordingHub, SignalRClient> _hubContext;

    public MainAppService(ISignalRServer signalRServer)
    {
        _hubContext = signalRServer.HubContext;
    }

    public async Task SendMessage()
    {
        await _hubContext.Clients.All.ReceiveMessage("来自主项目的消息");
    }
}

优势：主项目几乎无需修改SignalR配置，完全由类库管理；上下文与类库的SignalR Host强关联。
劣势：主项目依赖类库的ISignalRServer接口获取上下文，耦合度略高。

方案2：将类库SignalR配置整合到主项目Host（推荐） #

把类库的SignalR配置封装成扩展方法，主项目仅需调用扩展方法即可，让类库Hub与主项目共享同一个DI容器，IHubContext可直接注入使用。

类库中添加扩展方法： #

public static class RecordingHubExtensions
{
    public static IServiceCollection AddRecordingHub(this IServiceCollection services, ISignalRController signalRController)
    {
        // 注册类库依赖服务
        services.AddSingleton(signalRController);
        // 配置SignalR核心服务
        services.AddCors();
        services.AddSignalR()
            .AddJsonProtocol();
        return services;
    }

    public static IApplicationBuilder UseRecordingHub(this IApplicationBuilder app)
    {
        // 配置SignalR管道
        app.UseCors();
        app.UseRouting();
        app.UseAuthorization();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapHub<RecordingHub>("/api");
        });
        return app;
    }
}

主项目配置： #

// 主项目Program.cs
var builder = WebApplication.CreateBuilder(args);

// 1. 注册类库的SignalR服务
var signalRController = builder.Services.BuildServiceProvider().GetRequiredService<ISignalRController>();
builder.Services.AddRecordingHub(signalRController);

var app = builder.Build();

// 2. 启用类库的SignalR管道
app.UseRecordingHub();

// 其他主项目中间件配置...

app.Run();

主项目直接注入IHubContext： #

public class MainAppService
{
    private readonly IHubContext<RecordingHub, SignalRClient> _hubContext;

    // 直接注入即可，上下文与运行的Hub实例完全关联
    public MainAppService(IHubContext<RecordingHub, SignalRClient> hubContext)
    {
        _hubContext = hubContext;
    }
}

优势：符合.NET生态集成方式，主项目修改量极小；DI容器统一，避免多容器隔离问题。
劣势：类库不再独立启动SignalR Host，依赖主项目Host运行（若你的场景允许共享Host，这是最优解）。

方案3：共享DI容器（不推荐，耦合度高） #

让类库的SignalR Host使用主项目的DI容器作为父容器，同时将类库的IHubContext注册到主项目容器中。仅适用于必须让类库独立启动Host的场景。

修改类库的SignalRService： #

public async Task Start(IServiceProvider mainServiceProvider)
{
    _host = Host.CreateDefaultBuilder()
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.ConfigureServices(services =>
            {
                // 关联主项目DI容器作为父容器
                services.AddSingleton(mainServiceProvider);
                services.AddSingleton(_signalRController);
            });
            webBuilder.UseStartup<SignalRConfiguration>();
            webBuilder.UseUrls("https://url:port");
        })
        .Build();

    // 获取类库Hub上下文并注册到主项目容器
    var hubContext = _host.Services.GetRequiredService<IHubContext<RecordingHub, SignalRClient>>();
    var mainServices = mainServiceProvider.GetRequiredService<IServiceCollection>();
    mainServices.AddSingleton(hubContext);

    await _host.RunAsync();
}

主项目调用： #

// 主项目Program.cs
var sp = builder.Services.BuildServiceProvider();
var signalRService = sp.GetRequiredService<ISignalRServer>();
// 传递主项目的ServiceProvider
await signalRService.Start(sp);

优势：类库可独立启动Host，主项目仍能获取关联上下文。
劣势：需要主项目提前构建ServiceProvider，可能引发DI容器生命周期问题；耦合度高，不符合.NET最佳实践。

内容的提问来源于stack exchange，提问作者Mahnoor Fatima