Asp.Net Core 轻松学-基于微服务的后台任务调度管理器

前言

    在 Asp.Net Core 中，我们常常使用 System.Threading.Timer
这个定时器去做一些需要长期在后台运行的任务，但是这个定时器在某些场合却不太灵光，而且常常无法控制启动和停止，我们需要一个稳定的，类似 WebHost
这样主机级别的任务管理程序，但是又要比 WebHost 要轻便。

    由此，我找到了官方推荐的 IHostedService 接口，该接口位于程序集
Microsoft.Extensions.Hosting.Abstractions 的 命名空间
Microsoft.Extensions.Hosting。该接口自 .Net Core 2.0
开始提供，按照官方的说法，由于该接口的出现，下面的这些应用场景的代码都可以删除了。

历史场景列表

* 轮询数据库以查找更改的后台任务
* 从 Task.Run() 开始的后台任务
* 定期更新某些缓存的计划任务
* 允许任务在后台线程上执行的 QueueBackgroundWorkItem 实现
* 在 Web 应用后台处理消息队列中的消息，同时共享 ILogger 等公共服务
1. 原理解释

1.1 首先来看接口 IHostedService 的代码，这需要花一点时间去理解它的原理，你也可以跳过本段直接进入第二段
namespace Microsoft.Extensions.Hosting { // // Summary: // Defines methods for
objects that are managed by the host. public interface IHostedService { // //
Summary: // Triggered when the application host is ready to start the service.
Task StartAsync(CancellationToken cancellationToken); // // Summary: //
Triggered when the application host is performing a graceful shutdown. Task
StopAsync(CancellationToken cancellationToken); } }
1.2 非常简单，只有两个方法，但是非常重要，这两个方法分别用于程序启动和退出的时候调用，这和 Timer 有着云泥之别，这是质变。

1.3 从看到 IHostedService 这个接口开始，我就习惯性的想，按照微软的惯例，某个接口必然有其默认实现的抽象类，然后我就看到了
Microsoft.Extensions.Hosting.BackgroundService ，果然，前人种树后人乘凉，在 BackgroundService
类中，接口已经实现好了，我们只需要去实现 ExecuteAsync 方法

1.4 BackgroundService 内部代码如下，值得注意的是 BackgroundService 从 .Net Core 2.1
开始提供，所以，使用旧版本的同学们可能需要升级一下
public abstract class BackgroundService : IHostedService, IDisposable {
private Task _executingTask; private readonly CancellationTokenSource
_stoppingCts = new CancellationTokenSource(); protected abstract Task
ExecuteAsync(CancellationToken stoppingToken); public virtual Task
StartAsync(CancellationToken cancellationToken) { // Store the task we're
executing _executingTask = ExecuteAsync(_stoppingCts.Token); // If the task is
completed then return it, // this will bubble cancellation and failure to the
caller if (_executingTask.IsCompleted) { return _executingTask; } // Otherwise
it's running return Task.CompletedTask; } public virtual async Task
StopAsync(CancellationToken cancellationToken) { // Stop called without start
if (_executingTask == null) { return; } try { // Signal cancellation to the
executing method _stoppingCts.Cancel(); } finally { // Wait until the task
completes or the stop token triggers await Task.WhenAny(_executingTask,
Task.Delay(Timeout.Infinite, cancellationToken)); } } public virtual void
Dispose() { _stoppingCts.Cancel(); } }
1.5 BackgroundService 内部实现了 IHostedService 和 IDisposable
接口，从代码实现可以看出，BackgroundService 充分实现了任务启动注册和退出清理的逻辑，并保证在任务进入 GC 的时候及时的退出，这很重要。

2. 开始使用

2.1 首先创一个通用的任务管理类 BackManagerService ，该类继承自 BackgroundService
public class BackManagerService : BackgroundService { BackManagerOptions
options = new BackManagerOptions(); public
BackManagerService(Action<BackManagerOptions> options) {
options.Invoke(this.options); } protected override async Task
ExecuteAsync(CancellationToken stoppingToken) { // 延迟启动 await
Task.Delay(this.options.CheckTime, stoppingToken); options.OnHandler(0,
$"正在启动托管服务 [{this.options.Name}]...."); stoppingToken.Register(() => {
options.OnHandler(1, $"托管服务 [{this.options.Name}] 已经停止"); }); int count = 0;
while (!stoppingToken.IsCancellationRequested) { count++; options.OnHandler(1,
$" [{this.options.Name}] 第 {count} 次执行任务...."); try { options?.Callback(); if
(count == 3) throw new Exception("模拟业务报错"); } catch (Exception ex) {
options.OnHandler(2, $" [{this.options.Name}] 执行托管服务出错", ex); } await
Task.Delay(this.options.CheckTime, stoppingToken); } } public override Task
StopAsync(CancellationToken cancellationToken) { options.OnHandler(3, $"
[{this.options.Name}] 由于进程退出，正在执行清理工作"); return
base.StopAsync(cancellationToken); } }
* BackManagerService 类继承了 BackgroundService ，并实现了
ExecuteAsync(CancellationToken stoppingToken) 方法，在 ExecuteAsync
方法内，先是延迟启动任务，接下来进行注册和调度，这里使用 while 循环判断如果令牌没有取消，则一直轮询，而轮询的关键在于下面的代码 protected
override async Task ExecuteAsync(CancellationToken stoppingToken) { ... while
(!stoppingToken.IsCancellationRequested) { ... await
Task.Delay(this.options.CheckTime, stoppingToken); } }
while 循环内部使用 Task.Delay 设置时间，在 this.options.CheckTime 计时结束后继续下一轮的调度任务
实际上，Task.Delay 方法内部也是使用了 System.Threading.Timer 类进行计时，但是，当内部的 Timer
计时结束后，会马上被 Dispose 掉

2.2 任务管理类 BackManagerService 包含一个带参数的构造方法，是一个匿名委托，需要传入参数
BackManagerOptions，该参数表示一个任务的调度参数

2.3 创建 BackManagerOptions 任务调度操作类
public class BackManagerOptions { /// <summary> /// 任务名称 /// </summary>
public string Name { get; set; } /// <summary> /// 获取或者设置检查时间间隔，单位：毫秒，默认 10 秒
/// </summary> public int CheckTime { get; set; } = 10 * 1000; /// <summary>
/// 回调委托 /// </summary> public Action Callback { get; set; } /// <summary> ///
执行细节传递委托 /// </summary> public Action<BackHandler> Handler { get; set; } ///
<summary> /// 传递内部信息到外部组件中，以方便处理扩展业务 /// </summary> /// <param
name="level">0=Info，1=Debug，2=Error,3=exit</param> /// <param
name="message"></param> /// <param name="ex"></param> /// <param
name="state"></param> public void OnHandler(int level, string message,
Exception ex = null, object state = null) { Handler?.Invoke(new BackHandler() {
Level = level, Message = message, Exception = ex, State = state }); } }
2.4 该 BackManagerOptions 任务调度操作类包含了一些基础的设置内容，比如任务名称，执行周期间隔，回调委托
Callback，任务管理器内部执行细节传递委托 Handler，这些定义非常有用，下面会用到

2.5 其中，执行细节传递委托 Handler 包含一个参数，其实就是传递的细节，非常简单的一个实体对象类,无非就是信息级别，消息描述，异常信息，执行对象
public class BackHandler { /// <summary> /// 0=Info，1=Debug，2=Error ///
</summary> public int Level { get; set; } public string Message { get; set; }
public Exception Exception { get; set; } public object State { get; set; } }
2.6 定义好上面的 3 个对象后，现在来创建一个订单管理类，用于定时轮询数据库订单是否超时未付款，然后返还库存
public class OrderManagerService { public void CheckOrder() {
Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("==业务执行完成==");
Console.ForegroundColor = ConsoleColor.Gray; } public void
OnBackHandler(BackHandler handler) { switch (handler.Level) { default: case 0:
break; case 1: case 3: Console.ForegroundColor = ConsoleColor.Yellow; break;
case 2: Console.ForegroundColor = ConsoleColor.Red; break; }
Console.WriteLine("{0} | {1} | {2} | {3}", handler.Level, handler.Message,
handler.Exception, handler.State); Console.ForegroundColor = ConsoleColor.Gray;
if (handler.Level == 2) { // 服务执行出错，进行补偿等工作 } else if (handler.Level == 3) { //
退出事件，清理你的业务 CleanUp(); } } public void CleanUp() { Console.ForegroundColor =
ConsoleColor.Yellow; Console.WriteLine("==清理完成=="); Console.ForegroundColor =
ConsoleColor.Gray; } }
2.7 这个 OrderManagerService 业务类定义了 3 个方法，CheckOrder 检查订单，OnBackHandler
输出执行信息，CleanUp 在程序退出的时候去做一些清理工作，非常简单，前两个方法是用于注册到 BackManagerService
任务调度器中，后一个是内部方法。

3. 注册 BackManagerService 任务调度器到进程中

3.1 定义好业务类后，我们需要把它注册到进程中，以便程序启动和退出的时候自动执行

3.2 在 Startup.cs 的 ConfigureServices 方法中注册托管主机，看下面的代码
// This method gets called by the runtime. Use this method to add services to
the container. public void ConfigureServices(IServiceCollection services) {
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddSingleton<Microsoft.Extensions.Hosting.IHostedService,
BackManagerService>(factory => { OrderManagerService order = new
OrderManagerService(); return new BackManagerService(options => { options.Name
= "订单超时检查"; options.CheckTime = 5 * 1000; options.Callback = order.CheckOrder;
options.Handler = order.OnBackHandler; }); }); }
3.3 上面的代码通过将 BackManagerService 注册到托管主机中，并在初始化的时候设置了 BackManagerOptions ，然后将
OrderManagerService 的方法注册到 BackManagerOptions 的委托中，实现业务执行

3.4 运行程序，观察输出结果



3.4 输出结果清晰的表示创建的托管服务运行良好，我们来看一下执行顺序

执行顺序

* 启动托管服务
* 执行“订单超时检查”任务，连续执行了 3 次，间隔 5 秒，每次执行都向外部传递了执行细节信息
* 由于我们故意设置任务执行到第 3 次的时候模拟抛出异常，可以看到，异常被正确的捕获并安全的传递到外部
* 任务继续执行
* 强制终止了程序，然后托管服务收到了程序停止的信号并立即进行了清理工作，通知外部业务委托执行清理
* 清理完成，托管服务停止并退出
3.5 注册多个托管服务，通过定义的 BackManagerService 任务调度器，我们甚至具备了同时托管数个任务的能力，而我们只需要在
ConfigureServices 增加一行代码
public void ConfigureServices(IServiceCollection services) {
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddSingleton<Microsoft.Extensions.Hosting.IHostedService,
BackManagerService>(factory => { OrderManagerService order = new
OrderManagerService(); return new BackManagerService(options => { options.Name
= "订单超时检查"; options.CheckTime = 5 * 1000; options.Callback = order.CheckOrder;
options.Handler = order.OnBackHandler; }); });
services.AddSingleton<Microsoft.Extensions.Hosting.IHostedService,
BackManagerService>(factory => { OrderManagerService order = new
OrderManagerService(); return new BackManagerService(options => { options.Name
= "成交数量统计"; options.CheckTime = 2 * 1000; options.Callback = order.CheckOrder;
options.Handler = order.OnBackHandler; }); }); }
3.6 为了方便，我们还是使用 OrderManagerService 来模拟业务，只是把任务名称改成 "成交数量统计"，并设置任务执行周期间隔为 2 秒

3.7 现在来运行程序，观察输出



3.8 输出结果正常，两个托管服务独立运行，互不干扰，蓝色为 "成交数量统计"，白色为 "订单超时检查"

结语

* 得益于 .Net Core 提供的轻量型主机
IHostedService，我们可以方便的把后台任务注册到托管主机中，托管主机随着宿主进程的启动和退出执行相关的业务逻辑，这点非常重要，由于这种人性化的设计，我们可以在宿主进程启动和退出的时候去做一些业务级别的工作。
* 值得注意的是，IHostedService 中的方法 StartAsync
会在服务启动的时候马上执行，这可能导致宿主进程并未完全初始化业务数据，导致托管任务报错，所以我们采用了延迟启动，即在 StartAsync
内部使用代码阻止任务立即执行 protected override async Task ExecuteAsync(CancellationToken
stoppingToken) { // 延迟启动 await Task.Delay(this.options.CheckTime,
stoppingToken); ... }
* 在默认情况下， CancellationToken 令牌取消的超时时间为 5
秒，如果你希望留更多的时间给业务处理，可以通过下面的代码修改，比如本示例设置为 15 秒后超时 public static void
Main(string[] args) { CreateWebHostBuilder(args)
.UseShutdownTimeout(TimeSpan.FromSeconds(15)) .Build().Run(); }
* 本次行文略显罗嗦，代码量也稍大了一些，主要是希望大家可以去理解原理后，使用起来心里比较有底一些
示例代码下载

https://github.com/lianggx/EasyAspNetCoreDemo/tree/master/Ron.BackHost
<https://github.com/lianggx/EasyAspNetCoreDemo/tree/master/Ron.BackHost>

• « 上一篇：推荐算法概述（基于用户的协同过滤算法、基于物品的协同过滤算法、基于内容的推荐算法）
• » 下一篇：记阿里的第一次面试