.netcore worker service在一个worker里执行多个任务的方法

　最近，有一个项目要使用 Windows 服务，来做为一个软件项目的载体。我想了想，都已经到了跨平台的时代了，会不会有替换 Windows 服务的技术出现呢？于是，在网络上疯狂的搜索了一番，真实皇天不负苦心人，找到了一个答案，那就是 Worker Service。听说在 NET Core 3.0 的时代就新增了 Worker Service 的新项目模板，可以编写长时间运行的后台服务，并且能轻松的部署成 windows 服务或 linux 守护程序。如果安装的 vs2022 是中文版本，Worker Service 的项目名称就变成了辅助角色服务。 

关于Worker类，既可以写多个，比如 WorkerOne,WorkerTwo 来实现多个任务，也可以在一个Worker类里实现多任务，前者的demo代码如下：

using Furion.TimeCrontab;
 
namespace WorkerServiceTest
{
    public class Worker : BackgroundService
    {
        private readonly ILogger _logger;
 
 
        public Worker(ILogger logger)
        {
            _logger = logger;
        }
 
        //重写BackgroundService.StartAsync方法，在开始服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Worker starting at: {time}", DateTimeOffset.Now);
 
            await base.StartAsync(cancellationToken);
        }
 
 
 
 
        /// 
        /// 第一个 windows服务或linux守护程序 的处理逻辑，由RunTaskOne方法内部启动的Task任务线程进行处理，
        /// 同样可以从参数CancellationToken stoppingToken中的IsCancellationRequested属性，得知Worker Service服务是否已经被停止
        /// 
        /// 
        /// 
        protected async Task RunTaskOne(CancellationToken stoppingToken)
        {
            var _crontab = Crontab.SecondlyAt(1, 10, 20); // 每秒
 
            如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            //while (!stoppingToken.IsCancellationRequested)
            //{
            //    await Task.Delay(_crontab.GetSleepTimeSpan(DateTime.Now), stoppingToken);
 
            //    _logger.LogInformation("RunTaskOne running at: {time}", DateTimeOffset.Now);
            //    // Thread.Sleep(1000);
            //}
             
 
            //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            while (!stoppingToken.IsCancellationRequested)
            {
                await Task.Delay(_crontab.GetSleepTimeSpan(DateTime.Now), stoppingToken);
                await Task.Run(() =>
                {
 
                    _logger.LogInformation("RunTaskOne running at: {time}", DateTimeOffset.Now);
                }, stoppingToken); 
            }
 
 
 
        }
 
        /// 
        /// 第二个 windows服务或linux守护程序 的处理逻辑，由RunTaskTwo方法内部启动的Task任务线程进行处理，
        /// 同样可以从参数CancellationToken stoppingToken中的IsCancellationRequested属性，得知Worker Service服务是否已经被停止
        /// 
        /// 
        /// 
        protected async Task RunTaskTwo(CancellationToken stoppingToken)
        {
            var _crontab = Crontab.SecondlyAt(30, 35, 40); // / 每第 3，5，6 秒
 
            如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            //while (!stoppingToken.IsCancellationRequested)
            //{
            //    await Task.Delay(_crontab.GetSleepTimeSpan(DateTime.Now), stoppingToken);
 
            //    _logger.LogInformation("RunTaskTwo running at: {time}", DateTimeOffset.Now);
            //    // Thread.Sleep(1000);
            //}
 
            //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            while (!stoppingToken.IsCancellationRequested)
            {
                await Task.Delay(_crontab.GetSleepTimeSpan(DateTime.Now), stoppingToken);
                await Task.Run(() =>
                {
 
                    _logger.LogInformation("RunTaskTwo running at: {time}", DateTimeOffset.Now);
                }, stoppingToken);
            }
 
        }
 
        /// 
        /// 第三个 windows服务或linux守护程序 的处理逻辑，由RunTaskThree方法内部启动的Task任务线程进行处理，
        /// 同样可以从参数CancellationToken stoppingToken中的IsCancellationRequested属性，得知Worker Service服务是否已经被停止
        /// 
        /// 
        /// 
        protected async Task RunTaskThree(CancellationToken stoppingToken)
        {
            var _crontab = Crontab.SecondlyAt(45, 50, 55); // / 每第 3，5，6 秒
 
            如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            //while (!stoppingToken.IsCancellationRequested)
            //{
            //    await Task.Delay(_crontab.GetSleepTimeSpan(DateTime.Now), stoppingToken);
 
            //    _logger.LogInformation("RunTaskThree running at: {time}", DateTimeOffset.Now);
            //    // Thread.Sleep(1000);
            //}
 
            //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            while (!stoppingToken.IsCancellationRequested)
            {
                await Task.Delay(_crontab.GetSleepTimeSpan(DateTime.Now), stoppingToken);
                await Task.Run(() =>
                {
 
                    _logger.LogInformation("RunTaskThree running at: {time}", DateTimeOffset.Now);
                }, stoppingToken);
            }
        }
 
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            //while (!stoppingToken.IsCancellationRequested)
            //{
            //    _logger.LogInformation("Worker1 正在进行中 : {time}", DateTimeOffset.Now);
            //    await Task.Delay(1000, stoppingToken);
            //}
 
            try
            {
                RunTaskOne(stoppingToken);
                RunTaskTwo(stoppingToken);
                RunTaskThree(stoppingToken);
 
                await Task.CompletedTask;
                // await Task.WhenAll(taskOne, taskTwo, taskThree);//使用await关键字，异步等待RunTaskOne、RunTaskTwo、RunTaskThree方法返回的三个Task对象完成，这样调用ExecuteAsync方法的线程会立即返回，不会卡在这里被阻塞
            }
            catch (Exception ex)
            {
                //RunTaskOne、RunTaskTwo、RunTaskThree方法中，异常捕获后的处理逻辑，这里我们仅输出一条日志
                _logger.LogError(ex.Message);
            }
            finally
            {
                //Worker Service服务停止后，如果有需要收尾的逻辑，可以写在这里
            }
 
        }
 
        //重写BackgroundService.StopAsync方法，在结束服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Worker1 停止了 : {time}", DateTimeOffset.Now);
 
            await base.StopAsync(cancellationToken);
        }
 
    }
}

其他方法可以参考：

https://www.cnblogs.com/PatrickLiu/p/15834732.html

25. 辅助角色服务 | Furion

26.2 Cron 表达式 | Furion