学步园

<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.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.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.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 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-PCSQLEXPRESS;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...