前言

看过我之前博客的人应该都知道，我负责了相当久的部门数据同步相关的工作。其中的艰辛不赘述了。
随着需求的越来越复杂，最近windows的计划任务已经越发的不能满足我了，而且计划任务毕竟太弱智，总是会失败之类，强制结束之类的。

最近增加了一些复杂的参数，每天的任务对同步程序调用需要多次调用不同参数，我也终于打算不再忍受弱智的计划任务。最初测试了一下基于 IIS 的 Quart ，发现还是存在会被回收无法定时的情况，
在此之前我并未做过 Quart 相关的开发。我查了查相关资料，可以更改 IIS 设置修改定时回收的模式，可以通过访问站点来唤醒等，觉得不是很合适。而且综合业务的考虑，实在是没必要在内网客户机搭一个 Web 站点。
这样一来，干脆搞一个 WindowsService 得了，而且定时的场景还是比较常见的，写一份肯定不亏，以后还是用的上。而且也没尝试过基于 Core 写 WindowsService，正好借此机会学习一下。

Worker Service

使用 VS2019 ，安装了 .NET CORE 3.0 以上的 SDK ，安装SDK的时候最好也安装运行时，免得最后忘记。
项目模板自带的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Runtime.InteropServices;
  5. using System.Threading.Tasks;
  6. using Microsoft.Extensions.DependencyInjection;
  7. using Microsoft.Extensions.Hosting;
  8. namespace WorkerServiceTest
  9. {
  10.     public class Program
  11.     {
  12.         public static void Main(string[] args)
  13.         {
  14.             CreateHostBuilder(args).Build().Run();
  15.         }
  16.         public static IHostBuilder CreateHostBuilder(string[] args) =>
  17.       Host.CreateDefaultBuilder(args)
  18.       .ConfigureServices((hostContext, services) =>
  19.       {
  20.           services.AddHostedService<Worker>();
  21.       });
  22.         }
  23.     }
  24. }

Program.cs中，依旧是创建一个 IHost 并启动。为了方便进行依赖注入，可以创建一个 IServiceCollection 的扩展方法来进行相关服务的注册。
而 Worker 类已经提供了一个默认例子，其中有一个 ExecuteAsync 方法，可以直接执行后台任务。这个时候，直接F5就可以正常运行了实现了一个显示当前时间的程序。
Work 类继承 BackgroundService，并重写其 ExecuteAsync 方法。显而易见，ExecuteAsync 方法就是执行后台任务的入口。

Quartz.Net

Quartz.Net 是一个功能齐全的开源作业调度系统，可以在最小规模的应用程序到大型企业系统使用。
Quartz.Net有三个主要概念:

  • job 这是你想要运行的后台任务。
  • trigger trigger 控制 job 何时运行，通常按某种调度规则触发。
  • scheduler 它负责协调 job 和 trigger，根据 trigger 的要求执行 job。

ASP.NET Core 很好地支持通过 hosted services（托管服务）运行“后台任务”。当你的 ASP.NET Core 应用程序启动，托管服务也启动，并在应用程序的生命周期中在后台运行。

现在有了一个官方包 Quartz.Extensions.Hosting 实现使用 Quartz.Net 运行后台任务，所以把 Quartz.Net 添加到 ASP.NET Core 或 Worker Service 要简单得多。

Quartz.Net 3.2.0 通过 Quartz.Extensions.Hosting 引入了对该模式的直接支持。
Quartz.Extensions.Hosting 即可以用在ASP.NET Core应用程序，也可以用在基于“通用主机”的Worker Service。
虽然可以创建一个“定时”后台服务(例如，每10分钟运行一个任务)，但Quartz.NET提供了一个更加健壮的解决方案。
通过使用Cron trigger，你可以确保任务只在一天的特定时间(例如凌晨2:30)运行，或者只在特定的日子运行，或者这些时间的任意组合运行。
Quartz.Net还允许你以集群的方式运行应用程序的多个实例，以便在任何时候只有一个实例可以运行给定的任务。
Quartz.Net托管服务负责Quartz的调度。它将在应用程序的后台运行，检查正在执行的触发器，并在必要时运行相关的作业。
你需要配置调度程序，但不需要担心启动或停止它，IHostedService 会为你管理。

引用 Quartz.Net

你可以通过使用 dotnet add package Quartz.Extensions.Hosting 命令安装 Quartz.Net 包。
如果你查看项目的.csproj，它应该是这样的:

  1. <Project Sdk="Microsoft.NET.Sdk.Worker">
  2.   <PropertyGroup>
  3.     <TargetFramework>net5.0</TargetFramework>
  4.     <UserSecretsId>dotnet-QuartzWorkerService-9D4BFFBE-BE06-4490-AE8B-8AF1466778FD</UserSecretsId>
  5.   </PropertyGroup>
  6.   <ItemGroup>
  7.     <PackageReference Include="Microsoft.Extensions.Hosting" Version="5.0.0" />
  8.         <PackageReference Include="Quartz.Extensions.Hosting" Version="3.3.2" />
  9.   </ItemGroup>
  10. </Project>

添加 Quartz.Net 托管服务

注册Quartz.Net需要做两件事：

  1. 注册Quartz.Net需要的DI容器服务。
  2. 注册托管服务。

在 ASP.NET Core 中，通常会在 Startup.ConfigureServices() 方法中完成这两项操作。
但 Worker Services 不使用 Startup 类，所以我们在 Program.cs 中的 IHostBuilder 的 ConfigureServices 方法中注册它们:

  1.     public class Program
  2.     {
  3.         public static void Main(string[] args)
  4.         {
  5.             //...
  6.         }
  8.         public static IHostBuilder CreateHostBuilder(string[] args)
  9.         {
  10.             IHostBuilder hostBuilder = Host.CreateDefaultBuilder(args);
  11.             hostBuilder.ConfigureServices((hostContext, services) =>
  12.             {
  13.                 services.AddQuartz(q =>
  14.                 {
  15.                     q.UseMicrosoftDependencyInjectionScopedJobFactory();
  16.                     //q.InitJobAndTriggerFromJobsettings(hostContext.Configuration);
  17.                 });
  19.                 services.AddQuartzHostedService(q => q.WaitForJobsToComplete = true);
  20.                 //services.AddHostedService<Worker>();
  21.             });
  23.             //Windows
  24.             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
  25.             { hostBuilder.UseWindowsService(); }
  27.             //Linux
  28.             if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
  29.             { hostBuilder.UseSystemd(); }
  31.             return hostBuilder;
  32.         }
  33.     }
  34. }

UseMicrosoftDependencyInjectionScopedJobFactory 告诉 Quartz.NET 注册一个 IJobFactory，该 IJobFactory 通过从DI容器中创建 job。
方法中的 Scoped 部分意味着你的作业可以使用 scoped 服务，而不仅仅是 single 或 transient 服务。

WaitForJobsToComplete 用来设置确保当请求关闭时，Quartz.NET在退出之前优雅地等待作业结束。
如果你现在运行应用程序，将看到Quartz服务启动，并将大量日志转储到控制台，因为篇幅原因，此处不再贴出。

另外 可能有读者注意到了其中的 hostBuilder.UseWindowsService();/hostBuilder.UseSystemd();
这是关于跨平台的一段设置，稍后会有简单讲解。

此时，你已经让 Quartz 作为托管服务在你的应用程序中运行，但是没有任何job让它运行。在下一节中，我们将创建并注册一个简单的job。

创建 Job

因为我的场景是定时运行一个EXE，最常见的通用定时任务场景应该是调用一个接口。
这里举例一个打印日志的Job，我的相关源代码会在结尾处放出。

  1. using Quartz;
  2. using Serilog;
  3. using System;
  4. using System.Threading.Tasks;
  6. namespace AX.QuartzServer.Core.Jobs
  7. {
  8.     [DisallowConcurrentExecution]
  9.     public class TestJob : AXQuartzJob
  10.     {
  11.         public string Name { get { return "测试Job"; } }
  12.         public string Note { get { return "会打印日志"; } }
  14.         public Task Execute(IJobExecutionContext context)
  15.         {
  16.             Log.Logger.Information($"{Newtonsoft.Json.JsonConvert.SerializeObject(context.JobDetail.JobDataMap)}");
  17.             Log.Logger.Information($"Hello world! {DateTime.Now.ToLongTimeString()}");
  18.             return Task.CompletedTask;
  19.         }
  20.     }
  21. }

这里我使用了全局的 Serilog 来记录日志。所以和一般的日志不太一样。
我还用 [DisallowConcurrentExecution] 属性装饰了 job 。此属性防止Quartz.NET试图同时运行相同的作业。
它将定时的在日志或控制台中打印 Hello world! 和当前时间。
现在我们已经有了作业，我们需要将它与 trigger 一起注册到 DI 容器中。

启动时自动配置Job

Quartz.NET 为运行 job 提供了一些简单的 schedule，但最常见的方法之一是使用 Quartz.NET Cron 表达式，这里不再赘述。
因为我的场景是Windows服务，暂不考虑一些高级的，可以实时停止，注册Job，运行Job之类的封装。
所以决定是在启动时直接通过读取配置文件注册 Job。
下面是注册的关键代码：

  1.     public static class AXQuartzConfigExtensions
  2.     {
  3.         public static void InitJobAndTriggerFromJobsettings(this IServiceCollectionQuartzConfigurator quartz, IConfiguration configuration)
  4.         {
  5.             var allJobs = configuration.GetSection("Jobs").Get<List<BaseJobConfig>>();
  7.             Log.Logger.Information($"开始注册 Job");
  8.             Log.Logger.Information($"共获取到 {allJobs.Count} 个 Job");
  10.             foreach (var item in allJobs)
  11.             {
  12.                 Log.Logger.Information($"{JsonConvert.SerializeObject(item)}");
  14.                 var jobName = $"{item.JobType}_{item.Name}";
  15.                 var jobKey = new JobKey(jobName);
  16.                 Log.Logger.Information($"{nameof(jobKey)}_{jobKey}");
  18.                 var jobData = new JobDataMap();
  19.                 jobData.PutAll(ToIDictionary(item));
  21.                 if (item.JobType.ToLower().Contains("testjob"))
  22.                 { quartz.AddJob<Jobs.TestJob>(opts => { opts.WithIdentity(jobKey); opts.SetJobData(jobData); }); }
  23.                 if (item.JobType.ToLower().Contains("windowscmdjob"))
  24.                 { quartz.AddJob<Jobs.WindowsCMDJob>(opts => { opts.WithIdentity(jobKey); opts.SetJobData(jobData); }); }
  26.                 quartz.AddTrigger(opts => opts
  27.                     .ForJob(jobKey)
  28.                     .WithIdentity($"{jobName}_Trigger")
  29.                     .WithCronSchedule(item.Cron));
  30.             }
  32.             Log.Logger.Information($"结束注册 Job");
  33.         }
  35.         //...
  36.     }

从配置文件中读取了配置之后，为每个 job 创建唯一的 JobKey 。这用于将job与其trggier连接在一起。
用 AddJob 注册我们的 TestJob。它将 TestJob 添加到了 DI 容器中，这样就可以创建它。它还在内部向 Quartz 注册了job。
然后用 AddTrigger 添加触发器，
使用 JobKey 将 trigger 与一个 job 关联起来，并为 trigger 提供唯一的名称(在本例中不是必需的，但如果你在集群模式下运行quartz，这很重要)。
最后，为trigger 设置了 Cron 表达式， Cron 表达式来自配置文件，测试时我用的是每五秒一次。
其中有一些快速实现时未优化的弱智代码之类的，各位读者不用在意。

配置文件配置节：

  1. {
  2.   "Logging": {
  3.       //...
  4.     }
  5.   },
  7.   //任务配置 DEMO
  8.   "JobDemo": {
  9.     "Name": "唯一任务名称",
  10.     "JobType": "任务类型 windowscmdjob/testjob",
  11.     "Cron": "运行时间表达式"
  12.   },
  14.   "Jobs": [
  15.     {
  16.       "Name": "LogHelloWorldTest",
  17.       "JobType": "testjob",
  18.       "Cron": "0 0 */1 * * ?" //这是每小时一次
  19.       //"Cron": "0/5 * * * * ?" 这是每五秒一次
  20.     }
  21.   ]
  22. }

如果你现在运行你的应用程序，你会看到和以前一样的启动消息，然后每5秒你会看到HelloWorldJob写入控制台:
这就是搭建一个定时服务的全部关键内容了。

跨平台

在 Host.CreateDefaultBuilder(args) 增加相关环境的调用。
可以使用判断平台的一个函数： IsOSPlatform ，可以判断是否在Windows平台运行，并进行分别调用。

  1. 虽然程序可以正常执行，但是还不能正常部署为服务，需要依据平台添加对应的nuget包：
  2. windows服务，需要添加：
  3. Install-Package Microsoft.Extensions.Hosting.WindowsServices
  4. Linux服务，需要添加：
  5. Install-Package Microsoft.Extensions.Hosting.Systemd
  7. .UseWindowsService();
  8. .UseSystemd();

Windows下部署

管理员下运行cmd/powershell，执行
sc.exe create WorkerServiceTest binPath=【你编译后的exe路径，不需要带双引号】
提示 CreateService 成功 即安装成功了，可以输入下面的命令运行服务。
sc.exe start WorkerServiceTest
sc.exe负责管理服务，具体配置启动方式和删除，可以查看命令的帮助。另外，友情提醒，如果是在powershell中，不要省略这个.exe，sc有别的用处…

开源代码

https://github.com/aaxuan/AX.QuartzServer（请选择性的忽略其他仓库的垃圾代码 (^_^)

本文将同步发布到个人的语雀博客，欢迎使用语雀的小伙伴相互关注。
https://www.yuque.com/cuxuan

参考

https://devblogs.microsoft.com/aspnet/net-core-workers-as-windows-services/
https://devblogs.microsoft.com/dotnet/net-core-and-systemd/
https://docs.microsoft.com/en-us/dotnet/core/extensions/generic-host
https://dejanstojanovic.net/aspnet/2018/june/setting-up-net-core-servicedaemon-on-linux-os/
https://dotnetcoretutorials.com/2019/12/07/creating-windows-services-in-net-core-part-3-the-net-core-worker-way/
http://www.cnblogs.com/podolski/p/13890572.html
https://www.cnblogs.com/xhy0826/p/Net_Core_Windows_Service_Quartz.html
https://segmentfault.com/a/1190000038753018