c# - 如何优雅地关闭以下BackgroundService

Question

如何优雅地关闭以下 BackgroundService？我覆盖了StopAsync它似乎正在工作，但是有一种方法可以使用cancellationToken.Register(...)，但是，我不知道如何正确使用它，因为它继承了 IDisposable 并且它接受的方法是public void OnShutdown，这意味着我不能await异步那里的方法。

services.AddSingleton<LiveTradeManager>(); 
services.AddHostedService<BotManagerService>();
services.AddSingleton<IDiscordClient, DiscordClient>();

public class BotManagerService : BackgroundService
{
    private readonly ILogger<BotManagerService> _logger;
    private readonly IDiscordClient _discordClient;
    private readonly ITradeManager _tradeManager;

    public BotManagerService(ILogger<BotManagerService> logger, IOptions<ExchangeOptions> options, IDiscordClient discordClient,  ITradeManagerFactory tradeManagerFactory)
    {
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _discordClient = discordClient;
        _tradeManager = tradeManagerFactory.GetTradeManager(options.Value.TradeManagerType);
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await _tradeManager.StartAsync(stoppingToken).ConfigureAwait(false);
        await _discordClient.StartAsync().ConfigureAwait(false);

        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogDebug("Heartbeat");
            await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken).ConfigureAwait(false);
        }
    }

    public override async Task StopAsync(CancellationToken cancellationToken)
    {
        await base.StopAsync(cancellationToken).ConfigureAwait(false);

        await _tradeManager.StopAsync().ConfigureAwait(false);
        await _discordClient.StopAsync().ConfigureAwait(false);
    }
}

public interface ITradeManager
{
    Task StartAsync(CancellationToken cancellationToken);
    Task StopAsync();
}

public class LiveTradeManager : ITradeManager
{
    private readonly ILogger<LiveTradeManager> _logger;
    private readonly IBotClient _client;

    public LiveTradeManager(ILogger<LiveTradeManager> logger, IOptions<ExchangeOptions> options, IBotClientFactory clientFactory)
    {
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _client = clientFactory.GetBotClient(options.Value.BotClientType);
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        try
        {
            await SubscribeAsync().ConfigureAwait(false);
        }
        catch (CallFailedException ex)
        {
            _logger.LogCritical($"{ex.Message} | Stack trace: {ex.StackTrace}");
        }
    }

    public Task StopAsync()
    {
        return UnsubscribeAsync();
    }

    private UpdateSubscription _subscription;

    private async Task SubscribeAsync()
    {
        _logger.LogDebug("Subscribing to candlestick web socket stream.");

        _subscription = await _client.SubscribeToCandleUpdatesAsync("TRXUSDT", KlineInterval.OneMinute, CandleReceivedCallback).ConfigureAwait(false);
    }

    private Task UnsubscribeAsync()
    {
        if (_subscription == null) return Task.CompletedTask;

        _logger.LogDebug("Unsubscribing events.");

        return _client.UnsubscribeAsync(_subscription);
    }

    private void CandleReceivedCallback(IBinanceStreamKlineData data)
    {
        var ohlcv = data.Data.ToCandle();

        if (data.Data.Final)
        {
            _logger.LogInformation($"New candle | Open time: {ohlcv.Timestamp.ToDateTimeFormat()} | Price: {ohlcv.Close}");
        }
        else
        {
            _logger.LogInformation($"Candle update | Open time: {ohlcv.Timestamp.ToDateTimeFormat()} | Price: {ohlcv.Close}");
        }
    }
}

public class DiscordClient : IDiscordClient
{
    private readonly ILogger<DiscordClient> _logger;
    private readonly IServiceProvider _serviceProvider;
    private readonly DiscordOptions _options;
    private readonly DiscordSocketClient _client;
    private readonly CommandService _commandService;

    public DiscordClient(ILogger<DiscordClient> logger, IServiceProvider serviceProvider, IOptions<DiscordOptions> options, DiscordSocketClient client, CommandService commands)
    {
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _serviceProvider = serviceProvider;
        _options = options.Value;
        _client = client;
        _commandService = commands;
    }

    public async Task StartAsync()
    {
        if (string.IsNullOrEmpty(_options.Token)) return;
    
        _logger.LogDebug($"{nameof(DiscordClient)} is starting.");

        _client.Ready += DiscordClient_ReadyAsync;
        _client.MessageReceived += DiscordClient_HandleCommandAsync;
        _client.Log += DiscordClient_LogAsync;

        _commandService.CommandExecuted += DiscordClient_CommandExecutedAsync;
        _commandService.Log += DiscordClient_LogAsync;

        await _commandService.AddModulesAsync(Assembly.GetExecutingAssembly(), _serviceProvider).ConfigureAwait(false);

        await _client.LoginAsync(TokenType.Bot, _options.Token).ConfigureAwait(false);
        await _client.StartAsync().ConfigureAwait(false);
    }

    public async Task StopAsync()
    {
        if (string.IsNullOrEmpty(_options.Token)) return;

        _logger.LogDebug($"{nameof(DiscordClient)} is stopping.");

        await _client.SetStatusAsync(UserStatus.Offline).ConfigureAwait(false);
        await _client.SetGameAsync(null).ConfigureAwait(false);
        await _client.StopAsync().ConfigureAwait(false);

        _client.Ready -= DiscordClient_ReadyAsync;
        _client.MessageReceived -= DiscordClient_HandleCommandAsync;
        _client.Log -= DiscordClient_LogAsync;

        _commandService.CommandExecuted -= DiscordClient_CommandExecutedAsync;
        _commandService.Log -= DiscordClient_LogAsync;
    }
}

标签： c#background-serviceasp.net-core-5.0