ASP.NET Core中创建多个BackgroundService实例的方法及选型咨询

一、BackgroundService vs IHostedService 怎么选？ #

• 优先用BackgroundService：它是IHostedService的抽象基类，已经封装了StartAsync/StopAsync的基础生命周期逻辑，还提供了ExecuteAsync抽象方法让你专注编写任务核心逻辑，不用自己处理取消令牌管理、基础异常框架这些细节，对新手友好度拉满，队列处理这类常规场景完全够用。
• 直接实现IHostedService仅适用于复杂场景：如果你的后台任务需要完全自定义启动/停止的特殊流程（比如启动时要绑定特定资源、停止时要执行多步骤清理），才考虑直接实现IHostedService，一般情况没必要舍近求远。

二、创建多个队列处理的BackgroundService实例 #

1. 先定义通用消息队列 #

写一个通用的线程安全队列类，用来存储和分发消息：

public class MessageQueue<T>
{
    private readonly ConcurrentQueue<T> _queue = new ConcurrentQueue<T>();
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(0);

    public void Enqueue(T message)
    {
        _queue.Enqueue(message);
        _semaphore.Release();
    }

    public async Task<T> DequeueAsync(CancellationToken cancellationToken)
    {
        await _semaphore.WaitAsync(cancellationToken);
        _queue.TryDequeue(out var message);
        return message;
    }
}

2. 实现不同队列的处理器 #

针对不同业务的队列（比如订单消息、日志消息），分别继承BackgroundService实现专属处理器：

// 订单消息处理器
public class OrderMessageProcessor : BackgroundService
{
    private readonly MessageQueue<OrderMessage> _orderQueue;
    private readonly ILogger<OrderMessageProcessor> _logger;

    public OrderMessageProcessor(MessageQueue<OrderMessage> orderQueue, ILogger<OrderMessageProcessor> logger)
    {
        _orderQueue = orderQueue;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("订单消息处理器已启动");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                var message = await _orderQueue.DequeueAsync(stoppingToken);
                // 这里写订单消息的业务处理逻辑
                _logger.LogInformation($"处理订单：{message.OrderId}");
                await Task.Delay(1000, stoppingToken); // 模拟业务耗时
            }
            catch (OperationCanceledException)
            {
                _logger.LogInformation("订单消息处理器已停止");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "处理订单消息出错");
                await Task.Delay(5000, stoppingToken); // 出错后延迟重试
            }
        }
    }
}

// 日志消息处理器
public class LogMessageProcessor : BackgroundService
{
    private readonly MessageQueue<LogMessage> _logQueue;
    private readonly ILogger<LogMessageProcessor> _logger;

    public LogMessageProcessor(MessageQueue<LogMessage> logQueue, ILogger<LogMessageProcessor> logger)
    {
        _logQueue = logQueue;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("日志消息处理器已启动");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                var message = await _logQueue.DequeueAsync(stoppingToken);
                // 这里写日志消息的业务处理逻辑
                _logger.LogInformation($"处理日志：{message.LogContent}");
                await Task.Delay(500, stoppingToken); // 模拟业务耗时
            }
            catch (OperationCanceledException)
            {
                _logger.LogInformation("日志消息处理器已停止");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "处理日志消息出错");
                await Task.Delay(3000, stoppingToken);
            }
        }
    }
}

// 消息实体示例
public class OrderMessage { public int OrderId { get; set; } }
public class LogMessage { public string LogContent { get; set; } }

3. 注册服务到依赖注入容器 #

在Program.cs里把队列和处理器都注册进去，每个队列和对应的处理器都是独立实例：

var builder = WebApplication.CreateBuilder(args);

// 注册不同的消息队列
builder.Services.AddSingleton<MessageQueue<OrderMessage>>();
builder.Services.AddSingleton<MessageQueue<LogMessage>>();

// 注册多个BackgroundService实例
builder.Services.AddHostedService<OrderMessageProcessor>();
builder.Services.AddHostedService<LogMessageProcessor>();

var app = builder.Build();

app.Run();

4. 发送消息到队列 #

在控制器或其他服务中注入对应队列，即可发送消息让后台处理器处理：

[ApiController]
[Route("api/orders")]
public class OrdersController : ControllerBase
{
    private readonly MessageQueue<OrderMessage> _orderQueue;

    public OrdersController(MessageQueue<OrderMessage> orderQueue)
    {
        _orderQueue = orderQueue;
    }

    [HttpPost]
    public IActionResult SubmitOrder(OrderMessage order)
    {
        _orderQueue.Enqueue(order);
        return Ok("订单已提交，等待后台处理");
    }
}

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