// 1在api層 下載包  <PackageReference Include="Quartz.AspNetCore" Version="3.5.0" />
//2注入配置
//3 net6中  只有program類，直接在里面Build前面添加以下代碼
builder.Services.AddQuartz(q =>
{
    // base quartz scheduler, job and trigger configuration
});
// ASP.NET Core hosting
builder.Services.AddQuartzServer(options =>
{
    // when shutting down we want jobs to complete gracefully
    options.WaitForJobsToComplete = true;
});

using Quartz.Impl.Triggers;
namespace common
{
    public static class QuartzUtil
    {
        /// <summary>
        /// 驗(yàn)證 Cron 表達(dá)式是否有效
        /// </summary>
        /// <param name="cronExpression"></param>
        /// <returns></returns>
        public static bool IsValidExpression(this string cronExpression)
        {
            try
            {
                var trigger = new CronTriggerImpl();
                trigger.CronExpressionString = cronExpression;
                var date = trigger.ComputeFirstFireTimeUtc(null);
                return date != null;
            }
            catch //(Exception e)
            {
                return false;
            }
        }
    }
}

using Quartz;
using Quartz.Impl.Matchers;
namespace Common
{
    /// <summary>
    /// 任務(wù)調(diào)度服務(wù)
    /// </summary>
    public class QuartzJobService : ITransientSelfDependency
    {
        private readonly ISchedulerFactory _schedulerFactory;
        private readonly ResultfulApiJobFactory _resultfulApiJobFactory;
        public QuartzJobService(ISchedulerFactory schedulerFactory, ResultfulApiJobFactory resultfulApiJobFactory)
        {
            _schedulerFactory = schedulerFactory;
            _resultfulApiJobFactory = resultfulApiJobFactory;
        }
        /// <summary>
        /// 開始運(yùn)行一個(gè)調(diào)度器
        /// </summary>
        /// <param name="tasks"></param>
        /// <returns></returns>
        public async Task<bool> RunAsync(Z_SyncModules tasks)
        { 
            //1、通過調(diào)度工廠獲得調(diào)度器
            var scheduler = await _schedulerFactory.GetScheduler();
            var taskName = $"{tasks.Id}>{tasks.ModuleName}";
            //2、創(chuàng)建一個(gè)觸發(fā)器
            var trigger = TriggerBuilder.Create()
                .WithIdentity(taskName, taskName)
                .StartNow()
                .WithDescription(tasks.Description)
               // .WithSimpleSchedule(x => x.WithIntervalInSeconds((int)tasks.Frequency).RepeatForever())
                 觸發(fā)表達(dá)式 0 0 0 1 1 ?
                .WithCronSchedule(tasks.SyncTime)
                .Build();
            //3、創(chuàng)建任務(wù)
            var jobDetail = JobBuilder.Create<ResultfulApiJob>()
                            .WithIdentity(taskName, taskName)
                            .UsingJobData("TasksId", tasks.Id.ToString())
                            .Build();
            //4、寫入 Job 實(shí)例工廠 解決 Job 中取 ioc 對象
            scheduler.JobFactory = _resultfulApiJobFactory;
            //5、將觸發(fā)器和任務(wù)器綁定到調(diào)度器中
            await scheduler.ScheduleJob(jobDetail, trigger);
            //6、開啟調(diào)度器
            await scheduler.Start();
            Console.WriteLine("運(yùn)行成功：" + taskName);
            return await Task.FromResult(true);
        }
        /// <summary>
        /// 關(guān)閉調(diào)度器
        /// </summary>
        /// <param name="tasks"></param>
        /// <returns></returns>
        public async Task<bool> CloseAsync(Z_SyncModules tasks)
        {
            IScheduler scheduler = await _schedulerFactory.GetScheduler();
            var taskName = $"{tasks.Id}>{tasks.ModuleName}";
            var jobKeys = (await scheduler
                .GetJobKeys(GroupMatcher<JobKey>.GroupEquals(taskName)))
                .ToList().FirstOrDefault();
            if (jobKeys == null )
            {
                MessageBox.Show($"未找到任務(wù):{taskName}");
            }
            var triggers = await scheduler.GetTriggersOfJob(jobKeys);
            ITrigger trigger = triggers?.Where(x => x.JobKey.Name == taskName).FirstOrDefault();
            if (trigger == null)
            {
                MessageBox.Show($"未找到觸發(fā)器:{taskName}");
            }
            await scheduler.PauseTrigger(trigger.Key);
            await scheduler.UnscheduleJob(trigger.Key);// 移除觸發(fā)器
            await scheduler.DeleteJob(trigger.JobKey);
            Console.WriteLine("關(guān)閉成功："+ taskName);
            return await Task.FromResult(true);
        } 
    }
}

using Quartz;
using System.Diagnostics;
namespace HZY.Quartz.Service.Jobs
{
    /// <summary>
    /// Resultful 風(fēng)格 Api Job
    /// </summary>
    [DisallowConcurrentExecution]
    public class ResultfulApiJob : IJob
    {
        private readonly ApiRequestService _apiRequestService;
        private readonly IServiceProvider _provider;
        private readonly ILogger<ResultfulApiJob> _logger;
        public ResultfulApiJob(ApiRequestService apiRequestService, ILogger<ResultfulApiJob> logger, IServiceProvider provider)
        {
            _apiRequestService = apiRequestService;
            _logger = logger;
            _provider = provider;
        }
        public async Task Execute(IJobExecutionContext context)
        {
            try
            {
                Stopwatch _stopwatch = new Stopwatch();
                _stopwatch.Restart();
                 var tasksId = context.MergedJobDataMap.GetString("TasksId")?.ToString();
                if (string.IsNullOrWhiteSpace(tasksId))
                {
                    _logger.LogError("tasksId 空!");
                    return;
                }
                Z_SyncModules tasks = null;
                using (var scope = _provider.CreateScope())
                {
                    // 解析你的作用域服務(wù)
                    var service = scope.ServiceProvider.GetService<IAdminRepository<Z_SyncModules>>();
                    tasks = await service.SelectNoTracking.FirstOrDefaultAsync(w=>w.Id==Guid.Parse(tasksId));
                }
                if (tasks == null)
                {
                    _logger.LogError("tasks 空!");
                    return;
                }
                var time = DateTime.Now;
                var taskId = tasks?.Id ?? Guid.Empty;
                var text = $"{tasks.ModuleName}|組={tasks.ModuleName}|{time:yyyy-MM-dd}|StartTime={time: HH:mm:ss:fff}|";
                var result = await _apiRequestService.RequestAsync("Post", tasks.ApiUrl);
                if (!result.IsSuccess)
                {
                    _logger.LogError($"Web Api RequestAsync(); 請求失敗! WebApi 返回結(jié)果:{result.Message}");
                }
                _stopwatch.Stop();
                var endTime = $"{DateTime.Now:HH:mm:ss:fff}";
                //運(yùn)行結(jié)束記錄
                text += $"EndTime={endTime}|{_stopwatch.ElapsedMilliseconds} 毫秒|結(jié)果={result.Message}";
            }
            catch (Exception ex)
            {
                var message = $@"Message={ex.Message}\r\n
StackTrace={ex.StackTrace}\r\n
Source={ex.Source}\r\n";
                _logger.LogError(ex, message, null);
            }
        }
    }
}

using Quartz;
using Quartz.Spi;
namespace HZY.Services.Admin.QuartzJobTask
{
    /// <summary>
    /// IJob 對象無法構(gòu)造注入 需要此類實(shí)現(xiàn) 返回 注入后得 Job 實(shí)例
    /// </summary>
    public class ResultfulApiJobFactory : IJobFactory
    {
        private readonly IServiceProvider _serviceProvider;
        public ResultfulApiJobFactory(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }
        public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
        {
            //Job類型
            Type jobType = bundle.JobDetail.JobType;
            return _serviceProvider.GetService(jobType) as IJob;
        }
        public void ReturnJob(IJob job)
        {
            var disposable = job as IDisposable;
            disposable?.Dispose();
        }
    }
}

namespace Common
{
    /// <summary>
    /// WebApi 請求服務(wù)
    /// </summary>
    public class ApiRequestService : ITransientSelfDependency
    {
        private readonly ILogger<ApiRequestService> _logger;
        public ApiRequestService(ILogger<ApiRequestService> logger)
        {
            _logger = logger;
        }
        /// <summary>
        /// 請求數(shù)據(jù)
        /// </summary>
        /// <param name="requsetMode"></param>
        /// <param name="apiUrl"></param>
        /// <param name="headerKeyValue"></param>
        /// <returns></returns>
        public async Task<(bool IsSuccess, string Message)> RequestAsync(string requsetMode, string apiUrl, string headerKeyValue = null)
        {
            try
            {
                var headerKey = "HZY.Quartz.Job.Request";
                var headerValue = "Success";
                if (!string.IsNullOrWhiteSpace(headerKeyValue) && headerKeyValue.Contains("="))
                {
                    headerKey = headerKeyValue.Split('=')[0];
                    headerValue = headerKeyValue.Split('=')[1];
                }
                IFlurlRequest flurlRequest = apiUrl.WithHeader(headerKey, headerValue);
                if (flurlRequest == null)
                {
                    return (false, "flurlRequest 空指針！");
                }
                IFlurlResponse flurResponse = default;
                if (requsetMode == "Post")
                {
                    flurResponse = await flurlRequest.PostAsync();
                }
                if (requsetMode == "Get")
                {
                    flurResponse = await flurlRequest.GetAsync();
                }
                if (flurResponse == null)
                {
                    return (false, "flurResponse 空指針！");
                }
                var result = await flurResponse.GetStringAsync();
                if (string.IsNullOrWhiteSpace(result))
                {
                    return (false, "result 空指針！");
                }
                return (true, result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"接口請求異?！続piRequestService 》RequestAsync】：{ex.Message}");
                return (false, ex.Message);
            }
        }
    }
}

  services.AddTransient<ISchedulerFactory, StdSchedulerFactory>();  
        //Job 實(shí)例化工廠
        services.AddSingleton<ResultfulApiJobFactory>();
        //Reultful 風(fēng)格 api 請求 任務(wù)
        services.AddTransient<ResultfulApiJob>();

寫一個(gè) Worker 繼承 IHostedService 
里面的邏輯就寫，讀數(shù)據(jù)庫，循環(huán)加載任務(wù)，加載任務(wù)的方法就在上面的RUNAsync()
using System.Threading;
using System.Threading.Tasks;
namespace HZY.Quartz
{
    public class Worker : IHostedService
    {
        private readonly ILogger<Worker> _logger;
        private readonly IServiceProvider _provider;
        private readonly QuartzJobService _quartzJob;
        public Worker(ILogger<Worker> logger, QuartzJobService quartzJob, IServiceProvider provider)
        {
            _logger = logger;
            this._quartzJob = quartzJob;
            _provider = provider;
        }
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation($"程序服務(wù)開始 : {DateTime.Now}");
            List<Z_SyncModules> servicelist = new();
            using (var scope = _provider.CreateScope())
            {
                // 解析你的作用域服務(wù)
                var service = scope.ServiceProvider.GetService<xx>();
                if (service != null)
                {
                    servicelist = await service.Where(xx).ToListAsync();
                }
                _logger.LogInformation($"程序服務(wù)查詢定時(shí)任務(wù)列表成功 : {DateTime.Now}");
                foreach (var item in servicelist)
                {
                    //自動(dòng)恢復(fù)任務(wù)機(jī)制a
                    try
                    {
                        var result = await _quartzJob.RunAsync(item);
                        if (result)
                        {
                            _logger.LogInformation($"自動(dòng)開啟任務(wù)成功 [{DateTime.Now}]  ");
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, $"自動(dòng)開啟任務(wù)錯(cuò)誤 [{DateTime.Now}] : {ex.Message}");
                    }
                }
            }
            await StopAsync(cancellationToken); //在項(xiàng)目查詢運(yùn)行的時(shí)候運(yùn)行一次
        }
        public Task StopAsync(CancellationToken cancellationToken)
        {
            return Task.CompletedTask;
        }
    }
}