清单 3 显示了 CronTrigger 的一个示例。请注意 SchedulerFactory、Scheduler 和 JobDetail 的实例化，与 SimpleTrigger 示例中的实例化是相同的。在这个示例中，只是修改了触发器。这里指定的 cron 表达式（“0/5 * * * * ?”）安排任务每 5 秒执行一次。
清单3 CronTriggerRunner.cs
代码
1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4 using Common.Logging;
5 using Quartz;
6 using Quartz.Impl;
7 using System.Threading;
8
9 namespace QuartzBeginnerExample
10 {
11 public class CronTriggerRunner : IExample
12 {
13 public string Name
14 {
15 get { return GetType().Name; }
16 }
17
18 public virtual void Run()
19 {
20 ILog log = LogManager.GetLogger(typeof(CronTriggerRunner));
21
22 log.Info("------- Initializing -------------------");
23
24 // First we must get a reference to a scheduler
25 ISchedulerFactory sf = new StdSchedulerFactory();
26 IScheduler sched = sf.GetScheduler();
27
28 log.Info("------- Initialization Complete --------");
29
30 log.Info("------- Scheduling Jobs ----------------");
31
32 // jobs can be scheduled before sched.start() has been called
33
34 // job 1 will run every 20 seconds
35 JobDetail job = new JobDetail("job1", "group1", typeof(SimpleQuartzJob));
36 CronTrigger trigger = new CronTrigger("trigger1", "group1", "job1", "group1");
37 trigger.CronExpressionString = "0/20 * * * * ?";
38 sched.AddJob(job, true);
39 DateTime ft = sched.ScheduleJob(trigger);
40
41 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));
42
43 log.Info("------- Starting Scheduler ----------------");
44
45 // All of the jobs have been added to the scheduler, but none of the
46 // jobs
47 // will run until the scheduler has been started
48 sched.Start();
49
50 log.Info("------- Started Scheduler -----------------");
51
52 log.Info("------- Waiting five minutes... ------------");
53 try
54 {
55 // wait five minutes to show jobs
56 Thread.Sleep(300 * 1000);
57 // executing...
58 }
59 catch (ThreadInterruptedException)
60 {
61 }
62
63 log.Info("------- Shutting Down ---------------------");
64
65 sched.Shutdown(true);
66
67 log.Info("------- Shutdown Complete -----------------");
68
69 SchedulerMetaData metaData = sched.GetMetaData();
70 log.Info(string.Format("Executed {0} jobs.", metaData.NumJobsExecuted));
71 }
72
73 }
74 }
75
如上所示，只用作业和触发器，就能访问大量的功能。但是，Quartz 是个丰富而灵活的调度包，对于愿意研究它的人来说，它还提供了更多功能。下面看一下 Quartz 的一些高级特性。
作业管理和存储
作业一旦被调度，调度器需要记住并且跟踪作业和它们的执行次数。如果你的作业是30分钟后或每30秒调用，这不是很有用。事实上，作业执行需要非常准确和即时调用在被调度作业上的Execute()方法。Quartz通过一个称之为作业存储（JobStore）的概念来做作业存储和管理。
有效作业存储
Quartz提供两种基本作业存储类型。第一种类型叫做RAMJobStore，它利用通常的内存来持久化调度程序信息。这种作业存储类型最容易配置、构造和运行。Quartz.net缺省使用的就是RAMJobStore。对许多应用来说，这种作业存储已经足够了。
然而，因为调度程序信息是存储在被分配在内存里面，所以，当应用程序停止运行时，所有调度信息将被丢失。如果你需要在重新启动之间持久化调度信息，则将需要第二种类型的作业存储。为了修正这个问题，Quartz.NET 提供了 AdoJobStore。顾名思义，作业仓库通过 ADO.NET把所有数据放在数据库中。数据持久性的代价就是性能降低和复杂性的提高。它将所有的数据通过ADO.NET保存到数据库可中。它的配置要比 RAMJobStore稍微复杂，同时速度也没有那么快。但是性能的缺陷不是非常差，尤其是如果你在数据库表的主键上建立索引。
设置AdoJobStore
AdoJobStore 几乎可以在任何数据库上工作，它广泛地使用Oracle, MySQL, MS SQLServer2000, HSQLDB, PostreSQL 以及 DB2。要使用AdoJobStore，首先必须创建一套Quartz使用的数据库表，可以在Quartz 的database\tables找到创建库表的SQL脚本。如果没有找到你的数据库类型的脚本，那么找到一个已有的，修改成为你数据库所需要的。需要注意的一件事情就是所有Quartz库表名都以QRTZ_作为前缀（例如：表"QRTZ_TRIGGERS",及"QRTZ_JOB_DETAIL"）。实际上，可以你可以将前缀设置为任何你想要的前缀，只要你告诉AdoJobStore那个前缀是什么即可（在你的Quartz属性文件中配置）。对于一个数据库中使用多个scheduler实例，那么配置不同的前缀可以创建多套库表，十分有用。
一旦数据库表已经创建，在配置和启动 AdoJobStore之前，就需要作出一个更加重要的决策。你要决定在你的应用中需要什么类型的事务。如果不想将scheduling命令绑到其他的事务上，那么你可以通过对JobStore使用JobStoreTX来让Quartz帮你管理事务（这是最普遍的选择）。
最后的疑问就是如何建立获得数据库联接的数据源（DataSource）。Quartz属性中定义数据源是通过提供所有联接数据库的信息，让Quartz自己创建和管理数据源。
要使用AdoJobStore（假定使用StdSchedulerFactory），首先需要设置Quartz配置中的quartz.jobStore.type属性为Quartz.Impl.AdoJobStore.JobStoreTX, Quartz。
配置 Quartz使用 JobStoreTx
quartz.threadPool.type = Quartz.Simpl.SimpleThreadPool, Quartz
下一步，需要为JobStore 选择一个DriverDelegate ， DriverDelegate负责做指定数据库的所有ADO.NET工作。StdADO.NETDelegate是一个使用vanilla" ADO.NET代码（以及SQL语句）来完成工作的代理。如果数据库没有其他指定的代理，那么就试用这个代理。只有当使用 StdADO.NETDelegate发生问题时，我们才会使用数据库特定的代理（这看起来非常乐观。其他的代理可以在 Quartz.Impl.AdoJobStor命名空间找到。）。其他的代理包括PostgreSQLDelegate ( 专为PostgreSQL 7.x)。
一旦选择好了代理，就将它的名字设置给AdoJobStore。
配置AdoJobStore 使用DriverDelegate
quartz.threadPool.type = Quartz.Simpl.SimpleThreadPool, Quartz
接下来，需要为JobStore指定所使用的数据库表前缀（前面讨论过）。
配置AdoJobStore的数据库表前缀
quartz.jobStore.tablePrefix = QRTZ
然后需要设置JobStore所使用的数据源。必须在Quartz属性中定义已命名的数据源，比如，我们指定Quartz使用名为"default"的数据源（在配置文件的其他地方定义）。
配置 AdoJobStore使用数据源源的名字
properties["quartz.jobStore.dataSource"] = "default"
最后，需要配置数据源的使用的Ado.net数据提供者和数据库连接串，数据库连接串是标准的Ado.net 数据库连接的连接串。数据库提供者是关系数据库同Quartz.net之间保持低耦合的数据库的连接提供者.
配置AdoJobStore使用数据源源的数据库连接串和数据库提供者
quartz.dataSource.default.connectionString = Server=(local);Database=quartz;Trusted_Connection=True;
quartz.dataSource.default.provider= SqlServer-11
目前Quartz.net支持的以下数据库的数据提供者：
l SqlServer-11 - SQL Server driver for .NET Framework 1.1
l SqlServer-20 - SQL Server driver for .NET Framework 2.0
l OracleClient-20 - Microsoft''s Oracle Driver (comes bundled with .NET Framework)
l OracleODP-20 - Oracle''s Oracle Driver
l MySql-10 - MySQL Connector/.NET v. 1.0.7
l MySql-109 - MySQL Connector/.NET v. 1.0.9
l MySql-50 - MySQL Connector/.NET v. 5.0 (.NET 2.0)
l MySql-51 - MySQL Connector/:NET v. 5.1 (.NET 2.0)
l SQLite1044 - SQLite ADO.NET 2.0 Provider v. 1.0.44 (.NET 2.0)
如果Scheduler非常忙（比如，执行的任务数量差不多和线程池的数量相同，那么你需要正确地配置DataSource的连接数量为线程池数量。为了指示AdoJobStore所有的JobDataMaps中的值都是字符串，并且能以“名字-值”对的方式存储而不是以复杂对象的序列化形式存储在BLOB 字段中，应设置 quartz.jobStore.usePropertiess配置参数的值为"true"(这是缺省的方式)。这样做，从长远来看非常安全，这样避免了对存储在BLOB中的非字符串的序列化对象的类型转换问题。
清单 4 展示了 AdoJobStore提供的数据持久性。就像在前面的示例中一样，先从初始化 SchedulerFactory 和 Scheduler 开始。然后，不再需要初始化作业和触发器，而是要获取触发器群组名称列表，之后对于每个群组名称，获取触发器名称列表。请注意，每个现有的作业都应当用 Scheduler. RescheduleJob () 方法重新调度。仅仅重新初始化在先前的应用程序运行时终止的作业，不会正确地装载触发器的属性。
清单4 AdoJobStoreRunner.cs
代码
1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4 using System.Collections.Specialized;
5 using Quartz;
6 using Common.Logging;
7 using Quartz.Impl;
8 using System.Threading;
9
10 namespace QuartzBeginnerExample
11 {
12 public class AdoJobStoreRunner : IExample
13 {
14 public string Name
15 {
16 get { return GetType().Name; }
17 }
18
19 private static ILog _log = LogManager.GetLogger(typeof(AdoJobStoreRunner));
20
21 public virtual void CleanUp(IScheduler inScheduler)
22 {
23 _log.Warn("***** Deleting existing jobs/triggers *****");
24
25 // unschedule jobs
26 string[] groups = inScheduler.TriggerGroupNames;
27 for (int i = 0; i < groups.Length; i++)
28 {
29 String[] names = inScheduler.GetTriggerNames(groups[i]);
30 for (int j = 0; j < names.Length; j++)
31 inScheduler.UnscheduleJob(names[j], groups[i]);
32 }
33
34 // delete jobs
35 groups = inScheduler.JobGroupNames;
36 for (int i = 0; i < groups.Length; i++)
37 {
38 String[] names = inScheduler.GetJobNames(groups[i]);
39 for (int j = 0; j < names.Length; j++)
40 inScheduler.DeleteJob(names[j], groups[i]);
41 }
42 }
43
44 public virtual void Run(bool inClearJobs, bool inScheduleJobs)
45 {
46 NameValueCollection properties = new NameValueCollection();
47
48 properties["quartz.scheduler.instanceName"] = "TestScheduler";
49 properties["quartz.scheduler.instanceId"] = "instance_one";
50 properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz";
51 properties["quartz.threadPool.threadCount"] = "5";
52 properties["quartz.threadPool.threadPriority"] = "Normal";
53 properties["quartz.jobStore.misfireThreshold"] = "60000";
54 properties["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz";
55 properties["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.StdAdoDelegate, Quartz";
56 properties["quartz.jobStore.useProperties"] = "false";
57 properties["quartz.jobStore.dataSource"] = "default";
58 properties["quartz.jobStore.tablePrefix"] = "QRTZ_";
59 properties["quartz.jobStore.clustered"] = "true";
60 // if running MS SQL Server we need this
61 properties["quartz.jobStore.selectWithLockSQL"] = "SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = @lockName";
62
63 properties["quartz.dataSource.default.connectionString"] = @"Server=LIJUNNIN-PC\SQLEXPRESS;Database=quartz;Trusted_Connection=True;";
64 properties["quartz.dataSource.default.provider"] = "SqlServer-20";
65
66 // First we must get a reference to a scheduler
67 ISchedulerFactory sf = new StdSchedulerFactory(properties);
68 IScheduler sched = sf.GetScheduler();
69 if (inClearJobs)
70 {
71 CleanUp(sched);
72 }
73
74
75 _log.Info("------- Initialization Complete -----------");
76
77 if (inScheduleJobs)
78 {
79 _log.Info("------- Scheduling Jobs ------------------");
80
81 string schedId = sched.SchedulerInstanceId;
82
83 int count = 1;
84
85 JobDetail job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob));
86 // ask scheduler to re-Execute this job if it was in progress when
87 // the scheduler went down...
88 job.RequestsRecovery = true;
89 SimpleTrigger trigger = new SimpleTrigger("trig_" + count, schedId, 20, 5000L);
90
91 trigger.StartTime = DateTime.Now.AddMilliseconds(1000L);
92 sched.ScheduleJob(job, trigger);
93 _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)));
94
95 count++;
96 job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob));
97 // ask scheduler to re-Execute this job if it was in progress when
98 // the scheduler went down...
99 job.RequestsRecovery = (true);
100 trigger = new SimpleTrigger("trig_" + count, schedId, 20, 5000L);
101
102 trigger.StartTime = (DateTime.Now.AddMilliseconds(2000L));
103 sched.ScheduleJob(job, trigger);
104 _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)));
105
106 count++;
107 job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob));
108 // ask scheduler to re-Execute this job if it was in progress when
109 // the scheduler went down...
110 job.RequestsRecovery = (true);
111 trigger = new SimpleTrigger("trig_" + count, schedId, 20, 3000L);
112
113 trigger.StartTime = (DateTime.Now.AddMilliseconds(1000L));
114 sched.ScheduleJob(job, trigger);
115 _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)));
116
117 count++;
118 job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob));
119 // ask scheduler to re-Execute this job if it was in progress when
120 // the scheduler went down...
121 job.RequestsRecovery = (true);
122 trigger = new SimpleTrigger("trig_" + count, schedId, 20, 4000L);
123
124 trigger.StartTime = (DateTime.Now.AddMilliseconds(1000L));
125 sched.ScheduleJob(job, trigger);
126 _log.Info(string.Format("{0} will run at: {1} & repeat: {2}/{3}", job.FullName, trigger.GetNextFireTime(), trigger.RepeatCount, trigger.RepeatInterval));
127
128 count++;
129 job = new JobDetail("job_" + count, schedId, typeof(SimpleQuartzJob));
130 // ask scheduler to re-Execute this job if it was in progress when
131 // the scheduler went down...
132 job.RequestsRecovery = (true);
133 trigger = new SimpleTrigger("trig_" + count, schedId, 20, 4500L);
134
135 trigger.StartTime = (DateTime.Now.AddMilliseconds(1000L));
136 sched.ScheduleJob(job, trigger);
137 _log.Info(string.Format("{0} will run at: {1} & repeat: {2}/{3}", job.FullName, trigger.GetNextFireTime(), trigger.RepeatCount, trigger.RepeatInterval));
138 }
139 // jobs don't start firing until start() has been called...
140 _log.Info("------- Starting Scheduler ---------------");
141 sched.Start();
142 _log.Info("------- Started Scheduler ----------------");
143
144 _log.Info("------- Waiting for one hour... ----------");
145
146 Thread.Sleep(TimeSpan.FromHours(1));
147
148
149 _log.Info("------- Shutting Down --------------------");
150 sched.Shutdown();
151 _log.Info("------- Shutdown Complete ----------------");
152 }
153
154 public void Run()
155 {
156 bool clearJobs = true;
157 bool scheduleJobs = true;
158
159 AdoJobStoreRunner example = new AdoJobStoreRunner();
160 example.Run(clearJobs, scheduleJobs);
161
162 }
163 }
164 }
165
Quartz.net 作业调度框架所提供的 API 在两方面都表现极佳：既全面强大，又易于使用。Quartz 可以用于简单的作业触发，也可以用于复杂的 Ado.net持久的作业存储和执行。
