.NetCore Quartz 定时任务执行

.NetCore Quartz 定时任务执行

Quartz是一个非常好用的任务执行包 用cron表达式做定时时间，后续维护比较方便

• 准备

  1. 存放根据实际需要定时任务实体类型

  using System;
  namespace TaskJob.Interfaces
  {
      public class JobSchedule
      {
          public JobSchedule(Type jobType, string cronExpression)
          {
              JobType = jobType;
              CronExpression = cronExpression;
          }
  
          public Type JobType { get; }
          public string CronExpression { get; }
      }
  }
  
  

  2.存放根据实际需要定时任务实体类型执行方法 继承IJob

  IJob接口需要实现Execute(IJobExecutionContext context)

  using System.Threading.Tasks;
  using Microsoft.Extensions.Logging;
  using Quartz;
  namespace TaskJob
  {
      [DisallowConcurrentExecution]//Prevent running multiple instances of the same task
      public class TaskMessageJob : IJob
      {
          private readonly ILogger<TaskMessageJob> _logger;
          public TaskMessageJob(ILogger<TaskMessageJob> logger)//记录日志就加不记录的话 可以删除
          {
              _logger = logger;
          }
          public Task Execute(IJobExecutionContext context)
          {
              return Task.Run(() =>
              {
                  NLogging.NLogWebExtension.Info("【定时运行开始......】");
                  (new RedashAPIProcessModule()).GetRedashApiProcessResult("TaskMessageJob");
                  NLogging.NLogWebExtension.Info("【定时运行结束。】");
  
              });
          }
  
      }
  }
  

  3.继承IHostedService实现StartAsync,StopAsync

  using Microsoft.Extensions.Hosting;
  using Quartz;
  using Quartz.Spi;
  using System.Collections.Generic;
  using System.Threading;
  using System.Threading.Tasks;
  public class QuartzHostedService : IHostedService
  {
      private readonly ISchedulerFactory _schedulerFactory;
      private readonly IJobFactory _jobFactory;
      private readonly IEnumerable<JobSchedule> _jobSchedules;
  
      public QuartzHostedService(
          ISchedulerFactory schedulerFactory,
          IJobFactory jobFactory,
          IEnumerable<JobSchedule> jobSchedules)
      {
          _schedulerFactory = schedulerFactory;
          _jobSchedules = jobSchedules;
          _jobFactory = jobFactory;
      }
      public IScheduler Scheduler { get; set; }
  
      public async Task StartAsync(CancellationToken cancellationToken)
      {
          Scheduler = await _schedulerFactory.GetScheduler(cancellationToken);
          Scheduler.JobFactory = _jobFactory;
  
          foreach (var jobSchedule in _jobSchedules)
          {
              var job = CreateJob(jobSchedule);
              var trigger = CreateTrigger(jobSchedule);
  
              await Scheduler.ScheduleJob(job, trigger, cancellationToken);
          }
  
           await Scheduler.Start(cancellationToken);
      }
  
      public async Task StopAsync(CancellationToken cancellationToken)
      {
          await Scheduler?.Shutdown(cancellationToken);
      }
  
      private static IJobDetail CreateJob(JobSchedule schedule)
      {
          var jobType = schedule.JobType;
          return JobBuilder
              .Create(jobType)
              .WithIdentity(jobType.FullName)
              .WithDescription(jobType.Name)
              .Build();
      }
  
      private static ITrigger CreateTrigger(JobSchedule schedule)
      {
          return TriggerBuilder
              .Create()
              .WithIdentity($"{schedule.JobType.FullName}.trigger")
              .WithCronSchedule(schedule.CronExpression)
              .WithDescription(schedule.CronExpression)
              .Build();
      }
  }
  

• 使用

  1.注入TaskMessageJob 继承如IJob

   public static void AddJob(this IServiceCollection services)
      {
      services.AddSingleton<TaskMessageJob>();
      services.AddSingleton(new JobSchedule(
         jobType: typeof(TaskMessageJob),
         cronExpression: cronExpressionString)); // run cronExpression
     }
  

  2.开启任务QuartzHostedService

  public void ConfigureServices(IServiceCollection services)
  {
      services.AddJob();
      services.AddHostedService<QuartzHostedService>();//任务开启 
  }
  

• 最后

根据业务需要，怎么简单怎么来,如果需要定时很精确如（时:分）这种就可以用Quartz 来做程序,后续更改会方便点!