//----------------選自Quartz.Simpl.SimpleJobFactory類-------------
using System;
using Quartz.Logging;
using Quartz.Spi;
using Quartz.Util;
namespace Quartz.Simpl
{
 /// <summary> 
 /// The default JobFactory used by Quartz - simply calls 
 /// <see cref="ObjectUtils.InstantiateType{T}" /> on the job class.
 /// </summary>
 /// <seealso cref="IJobFactory" />
 /// <seealso cref="PropertySettingJobFactory" />
 /// <author>James House</author>
 /// <author>Marko Lahma (.NET)</author>
 public class SimpleJobFactory : IJobFactory
 {
  private static readonly ILog log = LogProvider.GetLogger(typeof (SimpleJobFactory));

  /// <summary>
  /// Called by the scheduler at the time of the trigger firing, in order to
  /// produce a <see cref="IJob" /> instance on which to call Execute.
  /// </summary>
  /// <remarks>
  /// It should be extremely rare for this method to throw an exception -
  /// basically only the case where there is no way at all to instantiate
  /// and prepare the Job for execution. When the exception is thrown, the
  /// Scheduler will move all triggers associated with the Job into the
  /// <see cref="TriggerState.Error" /> state, which will require human
  /// intervention (e.g. an application restart after fixing whatever
  /// configuration problem led to the issue with instantiating the Job).
  /// </remarks>
  /// <param name="bundle">The TriggerFiredBundle from which the <see cref="IJobDetail" />
  /// and other info relating to the trigger firing can be obtained.</param>
  /// <param name="scheduler"></param>
  /// <returns>the newly instantiated Job</returns>
  /// <throws> SchedulerException if there is a problem instantiating the Job. </throws>
  public virtual IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
  {
   IJobDetail jobDetail = bundle.JobDetail;
   Type jobType = jobDetail.JobType;
   try
   {
    if (log.IsDebugEnabled())
    {
     log.Debug($"Producing instance of Job '{jobDetail.Key}', class={jobType.FullName}");
    }

    return ObjectUtils.InstantiateType<IJob>(jobType);
   }
   catch (Exception e)
   {
    SchedulerException se = new SchedulerException($"Problem instantiating class '{jobDetail.JobType.FullName}'", e);
    throw se;
   }
  }

  /// <summary>
  /// Allows the job factory to destroy/cleanup the job if needed. 
  /// No-op when using SimpleJobFactory.
  /// </summary>
  public virtual void ReturnJob(IJob job)
  {
   var disposable = job as IDisposable;
   disposable?.Dispose();
  }
 }
}

//------------------節(jié)選自Quartz.Util.ObjectUtils類-------------------------
 public static T InstantiateType<T>(Type type)
{
  if (type == null)
  {
   throw new ArgumentNullException(nameof(type), "Cannot instantiate null");
  }
  ConstructorInfo ci = type.GetConstructor(Type.EmptyTypes);
  if (ci == null)
  {
   throw new ArgumentException("Cannot instantiate type which has no empty constructor", type.Name);
  }
  return (T) ci.Invoke(new object[0]);
}

// -------每小時將redis數(shù)據(jù)持久化到sqlite， 每日凌晨跳針，持久化昨天全天數(shù)據(jù)---------------------
public class UsageCounterSyncJob : IJob
{
  private readonly EqidDbContext _context;
  private readonly IDatabase _redisDB1;
  private readonly ILogger _logger;
  public UsageCounterSyncJob(EqidDbContext context, RedisDatabase redisCache, ILoggerFactory loggerFactory)
  {
   _context = context;
   _redisDB1 = redisCache[1];
   _logger = loggerFactory.CreateLogger<UsageCounterSyncJob>();
  }
   public async Task Execute(IJobExecutionContext context)
  {
   // 觸發(fā)時間在凌晨，則同步昨天的計數(shù)
   var _day = DateTime.Now.ToString("yyyyMMdd");
   if (context.FireTimeUtc.LocalDateTime.Hour == 0)
    _day = DateTime.Now.AddDays(-1).ToString("yyyyMMdd");

   await SyncRedisCounter(_day);
   _logger.LogInformation("[UsageCounterSyncJob] Schedule job executed.");
  }
  ......
 }

namespace EqidManager
{
 using IOCContainer = IServiceProvider;
 // Quartz.Net啟動后注冊job和trigger
 public class QuartzStartup
 {
  public IScheduler _scheduler { get; set; }

  private readonly ILogger _logger;
  private readonly IJobFactory iocJobfactory;
  public QuartzStartup(IOCContainer IocContainer, ILoggerFactory loggerFactory)
  {
   _logger = loggerFactory.CreateLogger<QuartzStartup>();
   iocJobfactory = new IOCJobFactory(IocContainer);
   var schedulerFactory = new StdSchedulerFactory();
   _scheduler = schedulerFactory.GetScheduler().Result;
   _scheduler.JobFactory = iocJobfactory;
  }

  public void Start()
  {
   _logger.LogInformation("Schedule job load as application start.");
   _scheduler.Start().Wait();

   var UsageCounterSyncJob = JobBuilder.Create<UsageCounterSyncJob>()
    .WithIdentity("UsageCounterSyncJob")
    .Build();

   var UsageCounterSyncJobTrigger = TriggerBuilder.Create()
    .WithIdentity("UsageCounterSyncCron")
    .StartNow()
    // 每隔一小時同步一次
    .WithCronSchedule("0 0 * * * ?")  // Seconds,Minutes,Hours，Day-of-Month，Month，Day-of-Week，Year（optional field）
    .Build();
   _scheduler.ScheduleJob(UsageCounterSyncJob, UsageCounterSyncJobTrigger).Wait();

   _scheduler.TriggerJob(new JobKey("UsageCounterSyncJob"));
  }

  public void Stop()
  {
   if (_scheduler == null)
   {
    return;
   }

   if (_scheduler.Shutdown(waitForJobsToComplete: true).Wait(30000))
    _scheduler = null;
   else
   {
   }
   _logger.LogCritical("Schedule job upload as application stopped");
  }
 }

 /// <summary>
 /// IOCJobFactory ：實現(xiàn)在Timer觸發(fā)的時候注入生成對應(yīng)的Job組件
 /// </summary>
 public class IOCJobFactory : IJobFactory
 {
  protected readonly IOCContainer Container;

  public IOCJobFactory(IOCContainer container)
  {
   Container = container;
  }

  //Called by the scheduler at the time of the trigger firing, in order to produce
  //  a Quartz.IJob instance on which to call Execute.
  public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
  {
   return Container.GetService(bundle.JobDetail.JobType) as IJob;
  }

  // Allows the job factory to destroy/cleanup the job if needed.
  public void ReturnJob(IJob job)
  {
  }
 }
}

//-------------------------------截取自Startup文件------------------------
......
services.AddTransient<UsageCounterSyncJob>();  // 這里使用瞬時依賴注入
services.AddSingleton<QuartzStartup>();
......

// 綁定Quartz.Net
public void Configure(IApplicationBuilder app, Microsoft.AspNetCore.Hosting.IApplicationLifetime lifetime, ILoggerFactory loggerFactory)
{
  var quartz = app.ApplicationServices.GetRequiredService<QuartzStartup>();
  lifetime.ApplicationStarted.Register(quartz.Start);
  lifetime.ApplicationStopped.Register(quartz.Stop);
}