1 public abstract class BackgroundService : IHostedService, IDisposable
 2 {
 3     private Task _executingTask;
 4     private readonly CancellationTokenSource _stoppingCts = new CancellationTokenSource();
 5 
 6     /// <summary>
 7     /// This method is called when the <see cref="IHostedService"/> starts. The implementation should return a task that represents
 8     /// the lifetime of the long running operation(s) being performed.
 9     /// /// </summary>
10     /// <param name="stoppingToken">Triggered when <see cref="IHostedService.StopAsync(CancellationToken)"/> is called.</param>
11     /// <returns>A <see cref="Task"/> that represents the long running operations.</returns>
12     protected abstract Task ExecuteAsync(CancellationToken stoppingToken);
13 
14     /// <summary>
15     /// Triggered when the application host is ready to start the service.
16     /// </summary>
17     /// <param name="cancellationToken">Indicates that the start process has been aborted.</param>
18     public virtual Task StartAsync(CancellationToken cancellationToken)
19     {
20         // Store the task we're executing
21         _executingTask = ExecuteAsync(_stoppingCts.Token);
22 
23         // If the task is completed then return it, this will bubble cancellation and failure to the caller
24         if (_executingTask.IsCompleted)
25         {
26             return _executingTask;
27         }
28 
29         // Otherwise it's running
30         return Task.CompletedTask;
31     }
32 
33     /// <summary>
34     /// Triggered when the application host is performing a graceful shutdown.
35     /// </summary>
36     /// <param name="cancellationToken">Indicates that the shutdown process should no longer be graceful.</param>
37     public virtual async Task StopAsync(CancellationToken cancellationToken)
38     {
39         // Stop called without start
40         if (_executingTask == null)
41         {
42             return;
43         }
44 
45         try
46         {
47             // Signal cancellation to the executing method
48             _stoppingCts.Cancel();
49         }
50         finally
51         {
52             // Wait until the task completes or the stop token triggers
53             await Task.WhenAny(_executingTask, Task.Delay(Timeout.Infinite, cancellationToken));
54         }
55 
56     }
57 
58     public virtual void Dispose()
59     {
60         _stoppingCts.Cancel();
61     }
62 }

 1 public class TaskWorkService : ITaskWorkService
 2 {
 3     public async Task TaskWorkAsync(CancellationToken stoppingToken)
 4     {
 5         while (!stoppingToken.IsCancellationRequested)
 6         {
 7             //执行任务
 8             Console.WriteLine($"{DateTime.Now}");
 9 
10             //周期性任务，于上次任务执行完成后，等待5秒，执行下一次任务
11             await Task.Delay(500);
12         }
13     }
14 }

builder.Services.AddScoped<ITaskWorkService, TaskWorkService>();

 1 public class BackgroundServiceDemo : BackgroundService
 2 {
 3     private readonly IServiceProvider _services;
 4 
 5     public BackgroundServiceDemo(IServiceProvider services)
 6     {
 7         _services = services;
 8     }
 9 
10     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
11     {
12         using var scope = _services.CreateScope();
13 
14         var taskWorkService = scope.ServiceProvider.GetRequiredService<ITaskWorkService>();
15 
16         await taskWorkService.TaskWorkAsync(stoppingToken);
17     }
18 }

builder.Services.AddHostedService<BackgroundServiceDemo>();