Worker Service 动态改变执行间隔

我有一个为所有工人提供基类的工人服务，它接受IOptionsMonitor构造函数参数。该监视器包含带有执行间隔值的选项对象实例。问题是如何动态改变间隔，即使await Task.Delay(Interval);被称为？我的意思是如果Interval值设置为一天，并且之后Task.Delay被调用的方法会更改，例如，更改为一小时 - 我仍然需要等待一天，并且只有在下一次调用时才会更新延迟。如果该房产我如何取消当前的延迟并开始新的延迟Interval值已更新？ 谢谢。

请参阅下面所附的代码：

public abstract class WorkerBase<TWorker, TWorkerOptions> : BackgroundService
    where TWorker : WorkerBase<TWorker, TWorkerOptions>
    where TWorkerOptions : IHaveIntervalProperty
{
    protected WorkerBase(IServiceProvider serviceProvider, ILogger<TWorker> logger, IOptionsMonitor<TWorkerOptions> options)
    {
        _logger = logger;
        _serviceProvider = serviceProvider;
        _workerName = typeof(TWorker).Name;
        Interval = options.CurrentValue.Interval;
        options.OnChange(UpdateOptions);
    }

    public TimeSpan Interval { get; private set; }

    public virtual void UpdateOptions(TWorkerOptions options)
        => Interval = options.Interval;

    public abstract Task DoWork(IServiceProvider provider);

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation(Logs.InformationWorkerRunning, _workerName, DateTime.UtcNow);

            try
            {
                using var scope = _serviceProvider.CreateScope();
                await DoWork(scope.ServiceProvider);
            }
            catch (Exception e)
            {
                _logger.LogCritical(e, e.Message);
            }
            finally
            {
                await Task.Delay(Interval, stoppingToken);
            }
        }
    }
}

好的，根据 @Panagiotis Kanavos 的评论，我想出了以下代码：

public abstract class RepeatableWorker<TWorker, TOptions> : IHostedService, IDisposable
    where TWorker : RepeatableWorker<TWorker, TOptions>
    where TOptions : IHaveIntervalProperty
{
    #region Fields
    private readonly IServiceProvider _serviceProvider;
    private protected readonly ILogger<TWorker> _logger;
    private readonly string _workerName;
    private Timer? _executionTimer;
    private TimeSpan _interval;
    #endregion

    #region Constructors
    protected RepeatableWorker(IServiceProvider serviceProvider,
                               ILogger<TWorker> logger,
                               IOptionsMonitor<TOptions> options)
    {
        _serviceProvider = serviceProvider;
        _logger = logger;
        _workerName = typeof(TWorker).Name;
        _interval = options.CurrentValue.Interval;
        options.OnChange(UpdateOptions);
    }
    #endregion

    #region Properties
    public TimeSpan Interval
    {
        get => _interval;
        private set
        {
            if (value != _interval)
            {
                _executionTimer?.Change(TimeSpan.Zero, value);
                _interval = value;
            }
        }
    }
    #endregion

    #region Public methods
    public virtual void UpdateOptions(TOptions options)
        => Interval = options.Interval;

    public abstract void DoWork(IServiceProvider serviceProvider);

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation(Logs.InformationWorkerStarting, _workerName, DateTime.UtcNow);
        _executionTimer = new(DoWorkInternal, null, TimeSpan.Zero, Interval);
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation(Logs.InformationWorkerStopping, _workerName, DateTime.UtcNow);
        _executionTimer?.Change(Timeout.Infinite, 0);
        return Task.CompletedTask;
    }

    public void Dispose()
    {
        GC.SuppressFinalize(this);

        _executionTimer?.Dispose();
    }
    #endregion

    #region Private methods
    private void DoWorkInternal(object? state)
    {
        try
        {
            _logger.LogInformation("Worker {0} running at {1}.", _workerName, DateTime.UtcNow);
            using var scope = _serviceProvider.CreateScope();
            DoWork(scope.ServiceProvider);
        }
        catch (Exception e)
        {
            _logger.LogCritical(e, e.Message);
        }
    }
    #endregion
}

And the IHaveIntervalProperty界面：

public interface IHaveIntervalProperty
{
    TimeSpan Interval { get; set; }
}

以防万一有人需要这样的解决方案。