// .NET 8
using ManageCore.Api;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddHostedService<DemoHostedService>();
var app = builder.Build();

using Microsoft.Extensions.Hosting;
namespace ManageCore.Api
{
    public class DemoHostedService : IHostedService, IDisposable
    {
        private Timer? _timer;
        public Task StartAsync(CancellationToken cancellationToken)
        {
            _timer = new Timer(DoWork, null, TimeSpan.Zero, TimeSpan.FromSeconds(5));
            return Task.CompletedTask;
        }
        private void DoWork(object? state)
        {
            Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss}");
        }
        public Task StopAsync(CancellationToken cancellationToken)
        {
            Console.WriteLine("StopAsync");
            return Task.CompletedTask;
        }
        public void Dispose()
        {
            _timer?.Dispose();
        }
    }
}

using ManageCore.Api;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddScoped<IDemoTaskWorkService, DemoTaskWorkService>();

public abstract class BackgroundService : IHostedService, IDisposable
{
    private Task _executingTask;
    private readonly CancellationTokenSource _stoppingCts = new CancellationTokenSource();
    /// <summary>
    /// This method is called when the <see cref="IHostedService"/> starts. The implementation should return a task that represents
    /// the lifetime of the long running operation(s) being performed.
    /// /// </summary>
    /// <param name="stoppingToken">Triggered when <see cref="IHostedService.StopAsync(CancellationToken)"/> is called.</param>
    /// <returns>A <see cref="Task"/> that represents the long running operations.</returns>
    protected abstract Task ExecuteAsync(CancellationToken stoppingToken);
    /// <summary>
    /// Triggered when the application host is ready to start the service.
    /// </summary>
    /// <param name="cancellationToken">Indicates that the start process has been aborted.</param>
    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;
    }
    /// <summary>
    /// Triggered when the application host is performing a graceful shutdown.
    /// </summary>
    /// <param name="cancellationToken">Indicates that the shutdown process should no longer be graceful.</param>
    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();
    }
}

namespace ManageCore.Api
{
    public interface IDemoTaskWorkService
    {
        /// <summary>
        /// 測試任務
        /// </summary>
        /// <param name="stoppingToken"></param>
        /// <returns></returns>
        Task TaskWorkAsync(CancellationToken stoppingToken);
    }
}

public class DemoTaskWorkService : IDemoTaskWorkService
{
      /// <summary>
      /// 任務執(zhí)行
      /// </summary>
      /// <param name="stoppingToken"></param>
      /// <returns></returns>
      public async Task TaskWorkAsync(CancellationToken stoppingToken)
      {
          while (!stoppingToken.IsCancellationRequested)
          {
              //執(zhí)行任務
              Console.WriteLine($"{DateTime.Now}");
              //周期性任務，于上次任務執(zhí)行完成后，等待5秒，執(zhí)行下一次任務
              await Task.Delay(500);
          }
      }
 }

namespace ManageCore.Api
{
    public class DemoBackgroundService : BackgroundService
    {
        private readonly IServiceProvider _services;
        public DemoBackgroundService(IServiceProvider services)
        {
            _services = services;
        }
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            using var scope = _services.CreateScope();
            var taskWorkService = scope.ServiceProvider.GetRequiredService<IDemoTaskWorkService>();
            await taskWorkService.TaskWorkAsync(stoppingToken);
        }
    }
}

builder.Services.AddHostedService<DemoBackgroundService>();