如何优雅地关闭以下 BackgroundService

如何解决如何优雅地关闭以下 BackgroundService

如何优雅地关闭以下 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,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;
    }
}