In this blog post I’ll be covering, 01: A few things to consider before you should schedule a Job using Quartz.Net 02: Setting up your solution to use Quartz.Net API 03: Quartz.Net configuration 04: Writing & scheduling a hello
world job with Quartz.Net If you are new to Quartz.Net I would recommend going through, A brief introduction to Quartz.net Walkthrough of Installing & Testing Quartz.Net as a Windows Service A few things to consider before you should schedule a Job using Quartz.Net - An instance of
the scheduler service - A trigger - And last but not
the least a job For example, if I wanted to schedule a script to run on
the server, I should be jotting down answers to
the below questions, a. Considering there are multiple machines set up with Quartz.Net windows service, how can I choose
the instance of Quartz.Net where I want my script to be run b. What will trigger
the execution of
the job c. How often do I want
the job to run d. Do I want
the job to run right away or start after a delay or may be have
the job start at a specific time e. What will happen to my job if Quartz.Net windows service is reset f. Do I want multiple instances of this job to run concurrently g. Can I pass parameters to
the job being executed by Quartz.Net windows service Setting up your solution to use Quartz.Net API 1. Create a new C# Console Application project and call it “HelloWorldQuartzDotNet” and add a reference to Quartz.Net.dll. I use
the NuGet Package Manager to add
the reference. This can be done by right clicking references and choosing Manage NuGet packages, from
the Nuget Package Manager choose Online from
the left panel and in
the search box on
the right search for Quartz.Net. Click Install on
the package “Quartz” (Screen shot below). 2. Right click
the project and choose Add New Item. Add a new Interface and call it ‘IScheduledJob.cs’. Mark
the Interface public and add
the signature for Run. Your interface should look like below. namespace HelloWorldQuartzDotNet
{
public interface IScheduledJob
{
void Run();
}
}
3. Right click
the project and choose Add new Item. Add a class and call it ‘Scheduled Job’. Use this class to implement
the interface ‘IscheduledJob.cs’. Look at
the pseudo code in
the implementation of
the Run method.
using System;
namespace HelloWorldQuartzDotNet
{
class ScheduledJob : IScheduledJob
{
public void Run()
{
// Get an instance of
the Quartz.Net scheduler
// Define
the Job to be scheduled
// Associate a trigger with
the Job
// Assign
the Job to
the scheduler
throw new NotImplementedException();
}
}
}
I’ll get into
the implementation in more detail, but let’s look at
the minimal configuration a sample configuration file for Quartz.Net service to work.
Quartz.Net configuration
In
the App.Config file copy
the below configuration
<?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="ServerScheduler" />
<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>
As you can see in
the configuration above, I have included
the instance name of
the quartz scheduler,
the thread pool type, count and priority,
the job store type has been defined as RAM. You have
the option of configuring that to ADO.NET JOB store. More details here.
Writing & scheduling a hello
world job with Quartz.Net
Once fully implemented
the ScheduleJob.cs class should look like below. I’ll walk you through
the details of
the implementation…
- GetScheduler() uses
the name of
the quartz.net and listens on localhost port 555 to try and connect to
the quartz.net windows service.
- Run() an attempt is made to start
the scheduler in case it is in standby mode
- I have defined a job “WriteHelloToConsole” (that’s
the name of
the job), this job belongs to
the group “IT”. Think of group as a logical grouping feature. It helps you bucket jobs into groups. Quartz.Net gives you
the ability to pause or delete all jobs in a group (We’ll look at that in some of
the future posts). I have requested for recovery of this job in case
the quartz.net service fails over to
the other node in
the cluster.
The jobType is “HelloWorldJob”. This is
the class that would be called to execute
the job. More details on this below…
- I have defined a trigger for my job. I have called
the trigger “WriteHelloToConsole”.
The Trigger works on
the cron schedule “0 0/1 * 1/1 * ? *” which means fire
the job once every minute. I would recommend that you look at www.cronmaker.com a free and great website to build and parse cron expressions.
The trigger has a priority 1. So, if two jobs are run at
the same time, this trigger will have high priority and will be run first.
- Use
the Job and Trigger to schedule
the job. This method returns a datetime offeset. It is possible to see
the next fire time for
the job from this variable.
using System.Collections.Specialized;
using System.Configuration;
using Quartz;
using System;
using Quartz.Impl;
namespace HelloWorldQuartzDotNet
{
class ScheduledJob : IScheduledJob
{
public void Run()
{
// Get an instance of
the Quartz.Net scheduler
var schd = GetScheduler();
// Start
the scheduler if its in standby
if (!schd.IsStarted)
schd.Start();
// Define
the Job to be scheduled
var job = JobBuilder.Create<HelloWorldJob>()
.WithIdentity("WriteHelloToConsole", "IT")
.RequestRecovery()
.Build();
// Associate a trigger with
the Job
var trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("WriteHelloToConsole", "IT")
.WithCronSchedule("0 0/1 * 1/1 * ? *") // visit http://www.cronmaker.com/ Queues
the job every minute
.WithPriority(1)
.Build();
// Assign
the Job to
the scheduler
var schedule = schd.ScheduleJob(job, trigger);
Console.WriteLine("Job '{0}' scheduled for '{1}'", "", schedule.ToString("r"));
}
// Get an instance of
the Quartz.Net scheduler
private static IScheduler GetScheduler()
{
try
{
var properties = new NameValueCollection();
properties["quartz.scheduler.instanceName"] = "ServerScheduler";
// set remoting expoter
properties["quartz.scheduler.proxy"] = "true";
properties["quartz.scheduler.proxy.address"] = string.Format("tcp://{0}:{1}/{2}", "localhost", "555",
"QuartzScheduler");
// Get a reference to
the scheduler
var sf = new StdSchedulerFactory(properties);
return sf.GetScheduler();
}
catch (Exception ex)
{
Console.WriteLine("Scheduler not available: '{0}'", ex.Message);
throw;
}
}
}
}
The above highlighted values have been taken from
the Quartz.config file, this file is available in
the Quartz.net server installation directory.
Implementation of my HelloWorldJob Class below.
The HelloWorldJob class gets called to execute
the job “WriteHelloToConsole” using
the once every minute trigger set up for this job.
The HelloWorldJob is a class that implements
the interface IJob. I’ll walk you through
the details of
the implementation…
- context is passed to
the method execute by
the quartz.net scheduler service. This has everything you need to pull out
the job, trigger specific information.
- for example. I have pulled out
the value of
the jobKey name,
the fire time and next fire time.
using Quartz;
using System;
namespace HelloWorldQuartzDotNet
{
class HelloWorldJob : IJob
{
public void Execute(IJobExecutionContext context)
{
try
{
Console.WriteLine("Job {0} fired @ {1} next scheduled for {2}", context.JobDetail.Key,
context.FireTimeUtc.Value.ToString("r"), context.NextFireTimeUtc.Value.ToString("r"));
Console.WriteLine("Hello World!");
}
catch (Exception ex)
{
Console.WriteLine("Failed: {0}", ex.Message);
}
}
}
}
I’ll add a call to call
the scheduler in
the Main method in Program.cs
using System;
using System.Threading;
namespace HelloWorldQuartzDotNet
{
class Program
{
static void Main(string[] args)
{
try
{
var sj = new ScheduledJob();
sj.Run();
Thread.Sleep(10000 * 10000);
}
catch (Exception ex)
{
Console.WriteLine("Failed: {0}", ex.Message);
}
}
}
}
This was third in
the series of posts on enterprise scheduling using Quartz.net, in
the next post I’ll be covering how to pass parameters to
the scheduled task scheduled on Quartz.net windows service. Thank you for taking
the time out and reading this blog post. If you enjoyed
the post, remember to subscribe to http://feeds.feedburner.com/TarunArora. Stay tuned!
