详细讲解Quartz.NET

<?xml version="1.0" encoding="utf-8" ?> 
<configuration> 
<configSections> 
<section name="quartz" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" /> 
</configSections> 
<quartz> 
<add key="quartz.scheduler.instanceName" value="ExampleDefaultQuartzScheduler" /> 
<add key="quartz.threadPool.type" value="Quartz.Simpl.SimpleThreadPool, Quartz" /> 
<add key="quartz.threadPool.threadCount" value="10" /> 
<add key="quartz.threadPool.threadPriority" value="2" /> 
<add key="quartz.jobStore.misfireThreshold" value="60000" /> 
<add key="quartz.jobStore.type" value="Quartz.Simpl.RAMJobStore, Quartz" /> 
</quartz> 
</configuration> 

using System; 
using System.Collections.Generic; 
using System.Text; 
using Common.Logging; 
using Quartz; 
namespace QuartzBeginnerExample 
{ 
public class SimpleQuartzJob : IJob 
{ 
private static ILog _log = LogManager.GetLogger(typeof(SimpleQuartzJob)); 
/// <summary> 
/// Called by the <see cref="IScheduler" /> when a 
/// <see cref="Trigger" /> fires that is associated with 
/// the <see cref="IJob" />. 
/// </summary> 
public virtual void Execute(JobExecutionContext context) 
{ 
try 
{ 
// This job simply prints out its job name and the 
// date and time that it is running 
string jobName = context.JobDetail.FullName; 
_log.Info("Executing job: " + jobName + " executing at " + DateTime.Now.ToString("r")); 
} 
catch (Exception e) 
{ 
_log.Info("--- Error in job!"); 
JobExecutionException e2 = new JobExecutionException(e); 
// this job will refire immediately 
e2.RefireImmediately = true; 
throw e2; 
} 
} 
} 
} 

using System; 
using System.Collections.Generic; 
using System.Text; 
using Common.Logging; 
using Quartz; 
using Quartz.Impl; 
namespace QuartzBeginnerExample 
{ 
public class SimpleTriggerRunner 
{ 
public virtual void Run() 
{ 
ILog log = LogManager.GetLogger(typeof(SimpleTriggerExample)); 
log.Info("------- Initializing -------------------"); 
// First we must get a reference to a scheduler 
ISchedulerFactory sf = new StdSchedulerFactory(); 
IScheduler sched = sf.GetScheduler(); 
log.Info("------- Initialization Complete --------"); 
log.Info("------- Scheduling Jobs ----------------"); 
// jobs can be scheduled before sched.start() has been called 
// get a "nice round" time a few seconds in the future... 
DateTime ts = TriggerUtils.GetNextGivenSecondDate(null, 15); 
// job1 will only fire once at date/time "ts" 
JobDetail job = new JobDetail("job1", "group1", typeof(SimpleJob)); 
SimpleTrigger trigger = new SimpleTrigger("trigger1", "group1"); 
// set its start up time 
trigger.StartTime = ts; 
// set the interval, how often the job should run (10 seconds here) 
trigger.RepeatInterval = 10000; 
// set the number of execution of this job, set to 10 times. 
// It will run 10 time and exhaust. 
trigger.RepeatCount = 100; 
// schedule it to run! 
DateTime ft = sched.ScheduleJob(job, trigger); 
log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", 
job.FullName, ft.ToString("r"), trigger.RepeatCount, (trigger.RepeatInterval / 1000))); 
log.Info("------- Starting Scheduler ----------------"); 
// All of the jobs have been added to the scheduler, but none of the jobs 
// will run until the scheduler has been started 
sched.Start(); 
log.Info("------- Started Scheduler -----------------"); 
log.Info("------- Waiting 30 seconds... --------------"); 
try 
{ 
// wait 30 seconds to show jobs 
Thread.Sleep(30 * 1000); 
// executing... 
} 
catch (ThreadInterruptedException) 
{ 
} 
log.Info("------- Shutting Down ---------------------"); 
sched.Shutdown(true); 
log.Info("------- Shutdown Complete -----------------"); 
// display some stats about the schedule that just ran 
SchedulerMetaData metaData = sched.GetMetaData(); 
log.Info(string.Format("Executed {0} jobs.", metaData.NumJobsExecuted)); 
} 
} 
} 

using System; 
using System.Collections.Generic; 
using System.Text; 
using Common.Logging; 
using Quartz; 
using Quartz.Impl; 
using System.Threading; 
namespace QuartzBeginnerExample 
{ 
public class CronTriggerRunner 
{ 
public virtual void Run() 
{ 
ILog log = LogManager.GetLogger(typeof(CronTriggerRunner)); 
log.Info("------- Initializing -------------------"); 
// First we must get a reference to a scheduler 
ISchedulerFactory sf = new StdSchedulerFactory(); 
IScheduler sched = sf.GetScheduler(); 
log.Info("------- Initialization Complete --------"); 
log.Info("------- Scheduling Jobs ----------------"); 
// jobs can be scheduled before sched.start() has been called 
// job 1 will run every 20 seconds 
JobDetail job = new JobDetail("job1", "group1", typeof(SimpleQuartzJob)); 
CronTrigger trigger = new CronTrigger("trigger1", "group1", "job1", "group1"); 
trigger.CronExpressionString = "0/20 * * * * ?"; 
sched.AddJob(job, true); 
DateTime ft = sched.ScheduleJob(trigger); 
log.Info(string.Format("{0} has been scheduled to run at: {1} and repeat based on expression: {2}", job.FullName, ft.ToString("r"), trigger.CronExpressionString)); 
log.Info("------- Starting Scheduler ----------------"); 
// All of the jobs have been added to the scheduler, but none of the 
// jobs 
// will run until the scheduler has been started 
sched.Start(); 
log.Info("------- Started Scheduler -----------------"); 
log.Info("------- Waiting five minutes... ------------"); 
try 
{ 
// wait five minutes to show jobs 
Thread.Sleep(300 * 1000); 
// executing... 
} 
catch (ThreadInterruptedException) 
{ 
} 
log.Info("------- Shutting Down ---------------------"); 
sched.Shutdown(true); 
log.Info("------- Shutdown Complete -----------------"); 
SchedulerMetaData metaData = sched.GetMetaData(); 
log.Info(string.Format("Executed {0} jobs.", metaData.NumJobsExecuted)); 
} 
} 
} 

public class AdoJobStoreRunner : IExample 
{ 
public string Name 
{ 
get { return GetType().Name; } 
} 
private static ILog _log = LogManager.GetLogger(typeof(AdoJobStoreRunner)); 
public virtual void CleanUp(IScheduler inScheduler) 
{ 
_log.Warn("***** Deleting existing jobs/triggers *****"); 
// unschedule jobs 
string[] groups = inScheduler.TriggerGroupNames; 
for (int i = 0; i < groups.Length; i++) 
{ 
String[] names = inScheduler.GetTriggerNames(groups[i]); 
for (int j = 0; j < names.Length; j++) 
inScheduler.UnscheduleJob(names[j], groups[i]); 
} 
// delete jobs 
groups = inScheduler.JobGroupNames; 
for (int i = 0; i < groups.Length; i++) 
{ 
String[] names = inScheduler.GetJobNames(groups[i]); 
for (int j = 0; j < names.Length; j++) 
inScheduler.DeleteJob(names[j], groups[i]); 
} 
} 
public virtual void Run(bool inClearJobs, bool inScheduleJobs) 
{ 
NameValueCollection properties = new NameValueCollection(); 
properties["quartz.scheduler.instanceName"] = "TestScheduler"; 
properties["quartz.scheduler.instanceId"] = "instance_one"; 
properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz"; 
properties["quartz.threadPool.threadCount"] = "5"; 
properties["quartz.threadPool.threadPriority"] = "Normal"; 
properties["quartz.jobStore.misfireThreshold"] = "60000"; 
properties["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz"; 
properties["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.StdAdoDelegate, Quartz"; 
properties["quartz.jobStore.useProperties"] = "false"; 
properties["quartz.jobStore.dataSource"] = "default"; 
properties["quartz.jobStore.tablePrefix"] = "QRTZ_"; 
properties["quartz.jobStore.clustered"] = "true"; 
// if running MS SQL Server we need this 
properties["quartz.jobStore.selectWithLockSQL"] = "SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = @lockName"; 
properties["quartz.dataSource.default.connectionString"] = @"Server=LIJUNNIN-PC\SQLEXPRESS;Database=quartz;Trusted_Connection=True;"; 
properties["quartz.dataSource.default.provider"] = "SqlServer-20"; 
// First we must get a reference to a scheduler 
ISchedulerFactory sf = new StdSchedulerFactory(properties); 
IScheduler sched = sf.GetScheduler(); 
if (inClearJobs) 
{ 
CleanUp(sched); 
} 
_log.Info("------- Initialization Complete -----------"); 
if (inScheduleJobs) 
{ 
_log.Info("------- Scheduling Jobs ------------------"); 
string schedId = sched.SchedulerInstanceId; 
int count = 1; 
JobDetail job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob)); 
// ask scheduler to re-Execute this job if it was in progress when 
// the scheduler went down... 
job.RequestsRecovery = true; 
SimpleTrigger trigger = new SimpleTrigger("trig_" + count, schedId, 20, 5000L); 
trigger.StartTime = DateTime.Now.AddMilliseconds(1000L); 
sched.ScheduleJob(job, trigger); 
_log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.FullName, trigger.GetNextFireTime(), trigger.RepeatCount, (trigger.RepeatInterval / 1000))); 
count++; 
job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob)); 
// ask scheduler to re-Execute this job if it was in progress when 
// the scheduler went down... 
job.RequestsRecovery = (true); 
trigger = new SimpleTrigger("trig_" + count, schedId, 20, 5000L); 
trigger.StartTime = (DateTime.Now.AddMilliseconds(2000L)); 
sched.ScheduleJob(job, trigger); 
_log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.FullName, trigger.GetNextFireTime(), trigger.RepeatCount, (trigger.RepeatInterval / 1000))); 
count++; 
job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob)); 
// ask scheduler to re-Execute this job if it was in progress when 
// the scheduler went down... 
job.RequestsRecovery = (true); 
trigger = new SimpleTrigger("trig_" + count, schedId, 20, 3000L); 
trigger.StartTime = (DateTime.Now.AddMilliseconds(1000L)); 
sched.ScheduleJob(job, trigger); 
_log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.FullName, trigger.GetNextFireTime(), trigger.RepeatCount, (trigger.RepeatInterval / 1000))); 
count++; 
job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob)); 
// ask scheduler to re-Execute this job if it was in progress when 
// the scheduler went down... 
job.RequestsRecovery = (true); 
trigger = new SimpleTrigger("trig_" + count, schedId, 20, 4000L); 
trigger.StartTime = (DateTime.Now.AddMilliseconds(1000L)); 
sched.ScheduleJob(job, trigger); 
_log.Info(string.Format("{0} will run at: {1} & repeat: {2}/{3}", job.FullName, trigger.GetNextFireTime(), trigger.RepeatCount, trigger.RepeatInterval)); 
count++; 
job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob)); 
// ask scheduler to re-Execute this job if it was in progress when 
// the scheduler went down... 
job.RequestsRecovery = (true); 
trigger = new SimpleTrigger("trig_" + count, schedId, 20, 4500L); 
trigger.StartTime = (DateTime.Now.AddMilliseconds(1000L)); 
sched.ScheduleJob(job, trigger); 
_log.Info(string.Format("{0} will run at: {1} & repeat: {2}/{3}", job.FullName, trigger.GetNextFireTime(), trigger.RepeatCount, trigger.RepeatInterval)); 
} 
// jobs don't start firing until start() has been called... 
_log.Info("------- Starting Scheduler ---------------"); 
sched.Start(); 
_log.Info("------- Started Scheduler ----------------"); 
_log.Info("------- Waiting for one hour... ----------"); 
Thread.Sleep(TimeSpan.FromHours(1)); 
_log.Info("------- Shutting Down --------------------"); 
sched.Shutdown(); 
_log.Info("------- Shutdown Complete ----------------"); 
} 
public void Run() 
{ 
bool clearJobs = true; 
bool scheduleJobs = true; 
AdoJobStoreRunner example = new AdoJobStoreRunner(); 
example.Run(clearJobs, scheduleJobs); 
} 
}