如何在特定时间触发.NET Core 3.1托管服务? [英] How to trigger .NET Core 3.1 Hosted Service at certain time?

问题描述

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

 受保护的重写异步任务ExecuteAsync(CancellationToken startingToken){var interval = _configuration.IntervalInSeconds * 1000;同时(！stoppingToken.IsCancellationRequested){//一些工作等待任务.Delay(interval，StoppingToken);}} 

启动应用程序时，将调用executeAsync方法，然后每分钟进行一次操作.现在，我只需要在特定时间执行此类操作.有什么方法可以实现这种行为?除了粗略计算下一个触发时间之外，我的问题是否有解决方案?感谢您的帮助.

解决方案

通过使用

i need to trigger hosted service at certain time, eg. everyday at 13:00 o'clock. Mine typical ExecuteAsync method seems like that:

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

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

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

When the application starts, the executeAsync method is called, and then some action is taking place every minute for example. Now i have to perform such an action only on certain hour. Is there any method to achieve such a behavior?? Is there any solution to my problem apart from rough calculating the next trigger time?? Thanks for any help.

解决方案

By using the Timer method, you could run the task at a specific time, calculate the timespan between the current and target time and pass it as the dueTime parameter.

code as below:

    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;
    }

Besides, the timer or Task.Delay() methods are more applied to executing a method at specified intervals, if you want to implement scheduled tasks, I suggest you could also try to use the Cronos package and the Cron Expressions to configure the scheduled task (reference: link).

The Cronos package is a lightweight but full-fledged library for parsing cron expressions and calculating next occurrences with time zones and daylight saving time in mind. The Cronos is an open source project sponsored by HangfireIO, and you can read detailed documentation from its GitHub repository. The details steps as below:

1. Install the Cronos package via NuGet.

2. Create a CronJobService service with the following code:

    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;
        }
    }
   

3. create a 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);
        }
    }
   

4. Register the ScheduleJob service in the ConfigureServices method.

    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);
    }
   

   Then the result as below:

这篇关于如何在特定时间触发.NET Core 3.1托管服务?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！