类库中使用Mass Transit时总线启停位置的技术咨询

首先，你说得完全对——每次请求都启停总线绝对是不合理的。总线启动涉及到建立与消息中间件（比如RabbitMQ、Azure Service Bus）的连接、初始化队列/交换器等资源，是个相对重的操作，频繁启停会严重影响性能，还可能导致资源泄漏。

类库本身确实没有像Web应用那样的Startup.cs或Program.cs入口来管理生命周期，所以正确的做法是：把总线的启停责任交给调用你的类库的宿主应用（比如ASP.NET Core、控制台应用、Windows服务等），类库只负责提供总线的配置和创建逻辑，以及基于总线的业务方法。

下面是具体的实现思路和代码示例：

1. 类库中封装总线创建逻辑，不管理生命周期 #

在类库中创建一个工厂类，负责创建总线实例和请求客户端，但不要在这里启动或停止总线：

public static class AccountingBusFactory
{
    // 封装总线的配置和创建
    public static IBusControl CreateAccountingBus()
    {
        return Bus.Factory.CreateUsingRabbitMq(cfg =>
        {
            // 根据你的实际中间件配置，这里以RabbitMQ为例
            var host = cfg.Host(new Uri("rabbitmq://localhost"), h =>
            {
                h.Username("guest");
                h.Password("guest");
            });

            // 如果需要接收响应，可以在这里配置接收端点
            cfg.ReceiveEndpoint(host, "accounting-response-queue", e =>
            {
                e.Consumer<AccountingResponseConsumer>();
            });
        });
    }

    // 封装请求客户端的创建
    public static IRequestClient<IAccountingRequest, IAccountingResponse> CreateRequestClient(IBusControl bus)
    {
        // 指定请求的目标地址和超时时间
        return bus.CreateRequestClient<IAccountingRequest, IAccountingResponse>(
            new Uri("exchange:accounting-requests"), 
            TimeSpan.FromSeconds(30));
    }
}

同时，在类库中实现业务逻辑时，通过依赖注入获取请求客户端，而不是自己创建总线：

public class AccountingIntegrationService
{
    private readonly IRequestClient<IAccountingRequest, IAccountingResponse> _requestClient;

    // 通过构造函数注入请求客户端
    public AccountingIntegrationService(IRequestClient<IAccountingRequest, IAccountingResponse> requestClient)
    {
        _requestClient = requestClient;
    }

    // 业务方法：处理集成请求并发送Mass Transit请求
    public async Task<IAccountingResponse> ProcessAccountingRequest(AccountingIntegration accountingIntegration)
    {
        var request = MapToAccountingRequest(accountingIntegration);
        return await _requestClient.Request(request);
    }

    // 映射逻辑，根据你的实际需求实现
    private AccountingRequest MapToAccountingRequest(AccountingIntegration source)
    {
        return new AccountingRequest
        {
            // 填充请求参数
        };
    }
}

2. 由宿主应用管理总线的生命周期 #

不同的宿主应用有不同的生命周期管理方式，下面举两个常见的例子：

案例1：ASP.NET Core Web应用 #

在Program.cs中注册总线为单例，并在应用启动时启动，停止时自动销毁：

var builder = WebApplication.CreateBuilder(args);

// 注册总线为单例，整个应用生命周期复用
builder.Services.AddSingleton<IBusControl>(_ => AccountingBusFactory.CreateAccountingBus());

// 注册请求客户端为单例
builder.Services.AddSingleton<IRequestClient<IAccountingRequest, IAccountingResponse>>(sp =>
{
    var bus = sp.GetRequiredService<IBusControl>();
    return AccountingBusFactory.CreateRequestClient(bus);
});

// 注册类库中的业务服务
builder.Services.AddScoped<AccountingIntegrationService>();

var app = builder.Build();

// 启动总线，并绑定应用停止事件，自动停止总线
var bus = app.Services.GetRequiredService<IBusControl>();
await bus.StartAsync(app.Lifetime.ApplicationStopping);

// 其他中间件配置...

app.Run();

案例2：控制台应用 #

在Main方法中手动管理总线的启动和停止：

async Task Main(string[] args)
{
    // 创建总线实例
    var bus = AccountingBusFactory.CreateAccountingBus();
    
    // 启动总线
    await bus.StartAsync();

    try
    {
        // 创建请求客户端
        var requestClient = AccountingBusFactory.CreateRequestClient(bus);
        
        // 实例化类库中的业务服务并调用方法
        var service = new AccountingIntegrationService(requestClient);
        var integrationModel = new AccountingIntegration();
        var response = await service.ProcessAccountingRequest(integrationModel);
        
        // 处理响应...
    }
    finally
    {
        // 应用退出时停止总线
        await bus.StopAsync();
    }
}

核心原则总结 #

• 总线是长期运行的资源：应该在应用启动时初始化一次，整个生命周期内复用，避免频繁启停。
• 类库不负责生命周期管理：类库的职责是提供业务逻辑和工具方法，生命周期管理是宿主应用的责任，这样你的类库可以被不同类型的宿主复用。
• 依赖注入优先：通过依赖注入传递IBusControl或IRequestClient，而不是在类库中硬编码创建和启停逻辑，提高代码的可测试性和灵活性。

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