如何在.NET中优雅实现两个独立WebApplication？现有方案存疑

针对你的需求，推荐两种更简洁、更符合.NET官方设计的实现方式，避免自定义IHostedService带来的繁琐和风险，同时解决共享内部逻辑的DI问题。

方案一：直接创建两个WebApplication并并行启动（推荐） #

这种方式无需额外托管服务，直接在Main方法中构建两个独立的Web应用，共享内部逻辑服务，并行启动即可。

using Microsoft.AspNetCore.SignalR;

// 1. 定义共享的内部逻辑服务
public interface IInternalLogic
{
    Task ProcessRequest(string data);
}

public class InternalLogic : IInternalLogic
{
    public Task ProcessRequest(string data)
    {
        // 这里实现你的内部业务逻辑
        return Task.CompletedTask;
    }
}

var sharedServices = new ServiceCollection();
// 注册共享单例服务（两个WebApp将共用同一个实例）
sharedServices.AddSingleton<IInternalLogic, InternalLogic>();

// 2. 构建SignalR WebApp
var signalRBuilder = WebApplication.CreateBuilder(args);
signalRBuilder.WebHost.UseUrls("http://localhost:5000");

// 将共享服务注入SignalR应用的DI容器
foreach (var service in sharedServices)
{
    signalRBuilder.Services.Add(service);
}

// 配置SignalR服务
signalRBuilder.Services.AddSignalR();
var signalRApp = signalRBuilder.Build();

// 配置SignalR中间件和路由
signalRApp.UseRouting();
signalRApp.MapHub<MySignalRHub>("/frontendHub");

// 3. 构建REST API WebApp
var apiBuilder = WebApplication.CreateBuilder(args);
apiBuilder.WebHost.UseUrls("http://localhost:5001");

// 注入共享服务到API应用的DI容器
foreach (var service in sharedServices)
{
    apiBuilder.Services.Add(service);
}

// 配置API服务
apiBuilder.Services.AddControllers();
var apiApp = apiBuilder.Build();

// 配置API中间件和路由
apiApp.UseRouting();
apiApp.MapControllers();

// 4. 并行启动两个Web应用
await Task.WhenAll(signalRApp.RunAsync(), apiApp.RunAsync());

// 示例SignalR Hub
public class MySignalRHub : Hub
{
    private readonly IInternalLogic _internalLogic;

    // 直接通过DI获取共享的内部逻辑服务
    public MySignalRHub(IInternalLogic internalLogic)
    {
        _internalLogic = internalLogic;
    }

    public async Task SendMessage(string message)
    {
        await _internalLogic.ProcessRequest(message);
        await Clients.All.SendAsync("ReceiveMessage", message);
    }
}

方案优势 #

• 无自定义托管服务：直接利用.NET官方的WebApplication生命周期管理，避免手动处理StartAsync/StopAsync带来的资源泄漏风险。
• 共享服务直接注入：内部逻辑以单例形式注册到共享服务集合，两个WebApp的DI容器都能直接获取，无需绕DI弯路。
• 架构清晰：SignalR和REST API各自配置独立，同时共享核心业务逻辑，完全匹配你的前端 <-> SignalR <-> 内部逻辑 <-> REST API <-> 内部服务架构。

方案二：基于主Host托管两个WebApplication #

如果需要共享日志、配置文件等Host级别的资源，可以通过主IHost托管两个Web应用，所有共享服务注册到主Host的DI容器中。

using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Hosting;

public interface IInternalLogic
{
    Task ProcessRequest(string data);
}

public class InternalLogic : IInternalLogic
{
    public Task ProcessRequest(string data)
    {
        return Task.CompletedTask;
    }
}

var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        // 注册共享服务（主Host的DI容器，两个WebApp均可访问）
        services.AddSingleton<IInternalLogic, InternalLogic>();
        
        // 注册两个Web应用的托管服务
        services.AddHostedService<SignalRHostedService>();
        services.AddHostedService<ApiHostedService>();
    })
    .Build();

await host.RunAsync();

// SignalR应用的托管服务
public class SignalRHostedService : IHostedService
{
    private readonly IServiceProvider _serviceProvider;
    private WebApplication? _app;

    public SignalRHostedService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        var builder = WebApplication.CreateBuilder(new WebApplicationOptions
        {
            Services = _serviceProvider.CreateScope().ServiceProvider
        });
        builder.WebHost.UseUrls("http://localhost:5000");
        builder.Services.AddSignalR();
        
        _app = builder.Build();
        _app.UseRouting();
        _app.MapHub<MySignalRHub>("/frontendHub");
        
        await _app.StartAsync(cancellationToken);
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        if (_app != null)
        {
            await _app.StopAsync(cancellationToken);
            await _app.DisposeAsync();
        }
    }
}

// API应用的托管服务
public class ApiHostedService : IHostedService
{
    private readonly IServiceProvider _serviceProvider;
    private WebApplication? _app;

    public ApiHostedService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        var builder = WebApplication.CreateBuilder(new WebApplicationOptions
        {
            Services = _serviceProvider.CreateScope().ServiceProvider
        });
        builder.WebHost.UseUrls("http://localhost:5001");
        builder.Services.AddControllers();
        
        _app = builder.Build();
        _app.UseRouting();
        _app.MapControllers();
        
        await _app.StartAsync(cancellationToken);
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        if (_app != null)
        {
            await _app.StopAsync(cancellationToken);
            await _app.DisposeAsync();
        }
    }
}

public class MySignalRHub : Hub
{
    private readonly IInternalLogic _internalLogic;

    public MySignalRHub(IInternalLogic internalLogic)
    {
        _internalLogic = internalLogic;
    }

    public async Task SendMessage(string message)
    {
        await _internalLogic.ProcessRequest(message);
        await Clients.All.SendAsync("ReceiveMessage", message);
    }
}

方案优势 #

• 共享Host资源：主Host统一管理配置、日志、依赖注入等，两个WebApp自动继承这些配置。
• 生命周期统一：由主Host负责两个WebApp的启动和停止，确保资源正确释放。

对比原方案的改进 #

• 去掉了自定义IHostedService的繁琐代码，避免手动管理Web应用生命周期的风险。
• 共享服务直接通过DI注入，无需手动传递实例，符合.NET依赖注入的设计原则。
• 代码结构更清晰，两个WebApp的配置和职责分离，易于维护和扩展。

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