c# - 如何在特定时间触发 .NET Core 3.1 托管服务？

Question

我需要在特定时间触发托管服务，例如。每天13:00。我的典型 ExecuteAsync 方法看起来像这样：

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
     var interval = _configuration.IntervalInSeconds * 1000;

     while (!stoppingToken.IsCancellationRequested)
     { 
         // some job

         await Task
             .Delay(interval, stoppingToken);
     }
}

当应用程序启动时，将调用 executeAsync 方法，然后例如每分钟执行一些操作。现在我必须只在特定时间执行这样的操作。有什么方法可以实现这种行为吗？除了粗略计算下一个触发时间之外，我的问题有什么解决方案吗？谢谢你的帮助。

score 7 · Accepted Answer

通过使用Timer 方法，您可以在特定时间运行任务，计算当前时间和目标时间之间的时间跨度，并将其作为 DueTime 参数传递。

代码如下：

    public Task StartAsync(CancellationToken cancellationToken)
    {
        //DateTime.Today: 00:00:00
        TimeSpan delayTime = DateTime.Today.AddHours(21) - DateTime.Now;
        TimeSpan intervalTime = TimeSpan.FromMinutes(1); //86400000s == 1 day
        _timer = new Timer(DoWork, null, delayTime, intervalTime);
        return Task.CompletedTask;
    }

另外，timer或者Task.Delay()方法更适用于在指定的时间间隔执行一个方法，如果你想实现定时任务，我建议你也可以尝试使用Cronos包和Cron Expressions来配置定时任务（参考：链接）。

Cronos 包是一个轻量级但功能齐全的库，用于解析 cron 表达式并在考虑时区和夏令时计算下一次出现。Cronos 是由 HangfireIO 赞助的开源项目，您可以从其 GitHub 存储库中阅读详细文档。详细步骤如下：

通过 NuGet安装Cronos包。

使用以下代码创建 CronJobService 服务：

 public abstract class CronJobService : IHostedService, IDisposable
 {
     private System.Timers.Timer _timer;
     private readonly CronExpression _expression;
     private readonly TimeZoneInfo _timeZoneInfo;

     protected CronJobService(string cronExpression, TimeZoneInfo timeZoneInfo)
     {
         _expression = CronExpression.Parse(cronExpression);
         _timeZoneInfo = timeZoneInfo;
     }

     public virtual async Task StartAsync(CancellationToken cancellationToken)
     {
         await ScheduleJob(cancellationToken);
     }

     protected virtual async Task ScheduleJob(CancellationToken cancellationToken)
     {
         var next = _expression.GetNextOccurrence(DateTimeOffset.Now, _timeZoneInfo);
         if (next.HasValue)
         {
             var delay = next.Value - DateTimeOffset.Now;
             if (delay.TotalMilliseconds <= 0)   // prevent non-positive values from being passed into Timer
             {
                 await ScheduleJob(cancellationToken);
             }
             _timer = new System.Timers.Timer(delay.TotalMilliseconds);
             _timer.Elapsed += async (sender, args) =>
             {
                 _timer.Dispose();  // reset and dispose timer
                 _timer = null;

                 if (!cancellationToken.IsCancellationRequested)
                 {
                     await DoWork(cancellationToken);
                 }

                 if (!cancellationToken.IsCancellationRequested)
                 {
                     await ScheduleJob(cancellationToken);    // reschedule next
                 }
             };
             _timer.Start();
         }
         await Task.CompletedTask;
     }

     public virtual async Task DoWork(CancellationToken cancellationToken)
     {
         await Task.Delay(5000, cancellationToken);  // do the work
     }

     public virtual async Task StopAsync(CancellationToken cancellationToken)
     {
         _timer?.Stop();
         await Task.CompletedTask;
     }

     public virtual void Dispose()
     {
         _timer?.Dispose();
     }
 }

 public interface IScheduleConfig<T>
 {
     string CronExpression { get; set; }
     TimeZoneInfo TimeZoneInfo { get; set; }
 }

 public class ScheduleConfig<T> : IScheduleConfig<T>
 {
     public string CronExpression { get; set; }
     public TimeZoneInfo TimeZoneInfo { get; set; }
 }

 public static class ScheduledServiceExtensions
 {
     public static IServiceCollection AddCronJob<T>(this IServiceCollection services, Action<IScheduleConfig<T>> options) where T : CronJobService
     {
         if (options == null)
         {
             throw new ArgumentNullException(nameof(options), @"Please provide Schedule Configurations.");
         }
         var config = new ScheduleConfig<T>();
         options.Invoke(config);
         if (string.IsNullOrWhiteSpace(config.CronExpression))
         {
             throw new ArgumentNullException(nameof(ScheduleConfig<T>.CronExpression), @"Empty Cron Expression is not allowed.");
         }

         services.AddSingleton<IScheduleConfig<T>>(config);
         services.AddHostedService<T>();
         return services;
     }
 }

创建一个 ScheduleJob.cs：

 public class ScheduleJob: CronJobService
 {
     private readonly ILogger<ScheduleJob> _logger;

     public ScheduleJob(IScheduleConfig<ScheduleJob> config, ILogger<ScheduleJob> logger)
         : base(config.CronExpression, config.TimeZoneInfo)
     {
         _logger = logger;
     }

     public override Task StartAsync(CancellationToken cancellationToken)
     {
         _logger.LogInformation("ScheduleJob starts.");
         return base.StartAsync(cancellationToken);
     }

     public override Task DoWork(CancellationToken cancellationToken)
     {
         _logger.LogInformation($"{DateTime.Now:hh:mm:ss} ScheduleJob is working.");
         return Task.CompletedTask;
     }

     public override Task StopAsync(CancellationToken cancellationToken)
     {
         _logger.LogInformation("ScheduleJob is stopping.");
         return base.StopAsync(cancellationToken);
     }
 }

在 ConfigureServices 方法中注册 ScheduleJob 服务。

 public void ConfigureServices(IServiceCollection services)
 {
     services.AddHostedService<HelloWorldHostedService>(); 

     services.AddCronJob<ScheduleJob>(c=>
     {
         c.TimeZoneInfo = TimeZoneInfo.Local;
         c.CronExpression = @"25 21 * * *"; // 21:25 PM daily.
     });

     services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
 }

然后结果如下：

c# - 如何在特定时间触发 .NET Core 3.1 托管服务？

1 回答 1

Related

Reference