Simple Triggers

Use a SimpleTrigger to run a job once at a specific moment, or at a moment and then repeatedly at an interval: for example, at exactly 11:23:54 AM on January 13, 2005, and then five more times, every ten seconds.

• A trigger that repeats needs a positive interval: scheduling one with a zero interval throws SchedulerException ("Repeat Interval cannot be zero."). To run several firings at once, schedule several one-shot triggers.
• Start and end times carry an offset, so they are unambiguous. Compute one from DateTimeOffset.UtcNow; in code that has a TimeProvider (a job, a test), read the clock from it, as DateBuilder.Create(timeProvider) does.
• To fire every 10 seconds until a given moment, set the end time and a repeat count of RepeatIndefinitely instead of computing the number of repeats. A repeat count larger than the number of firings before the end time also works.

Build a SimpleTrigger with TriggerBuilder (the main properties) and its WithSimpleSchedule extension method (the SimpleTrigger-specific properties).

A specific moment in time, with no repeats:

// trigger builder creates simple trigger by default
ITrigger trigger = TriggerBuilder.Create()
    .WithIdentity("trigger1", "group1")
    .StartAt(myStartTime) // some Date
    .ForJob("job1", "group1") // identify job with name, group strings
    .Build();

The trigger family interfaces (ISimpleTrigger and friends) are read models: cast to one to inspect a trigger's schedule, never to change it. To change a schedule, rebuild the trigger with trigger.GetTriggerBuilder() and pass it to IScheduler.RescheduleJob.

A specific moment in time, then every ten seconds ten times:

ITrigger trigger = TriggerBuilder.Create()
    .WithIdentity("trigger3", "group1")
    .StartAt(myTimeToStartFiring) // if a start time is not given (if this line were omitted), "now" is implied
    .WithSimpleSchedule(x => x
        .WithInterval(TimeSpan.FromSeconds(10))
        .WithRepeatCount(10)) // note that 10 repeats will give a total of 11 firings
    .ForJob(myJob) // identify job with handle to its JobDetail itself
    .Build();

Once, five minutes in the future:

ITrigger trigger = TriggerBuilder.Create()
    .WithIdentity("trigger5", "group1")
    .StartAt(DateTimeOffset.UtcNow.AddMinutes(5))
    .ForJob(myJobKey) // identify job with its JobKey
    .Build();

Now, then every five minutes, until 22:00:

ITrigger trigger = TriggerBuilder.Create()
    .WithIdentity("trigger7", "group1")
    .WithSimpleSchedule(x => x
        .WithInterval(TimeSpan.FromMinutes(5))
        .RepeatForever())
    .EndAt(DateBuilder.Create().AtHourMinuteAndSecond(22, 0, 0).Build())
    .Build();

At the top of the next hour, then every 2 hours, forever:

ITrigger trigger = TriggerBuilder.Create()
    .WithIdentity("trigger8") // because group is not specified, "trigger8" will be in the default group
    .StartAt(DateBuilder.Create().AtMinute(0).AtSecond(0).Build().AddHours(1)) // the next even hour
    .WithSimpleSchedule(x => x
        .WithInterval(TimeSpan.FromHours(2))
        .RepeatForever())
    // note that in this example, 'ForJob(..)' is not called
    //  - which is valid if the trigger is passed to the scheduler along with the job
    .Build();

await scheduler.ScheduleJob(job, trigger);

TriggerBuilder and WithSimpleSchedule have more options than these examples show.

Measured from completion

MeasureIntervalFromCompletion() makes the interval a fixed delay: the next run starts one interval after the previous run completes, however long it took. The default is a fixed rate, measured from each run's scheduled time. From 4.7.

ITrigger trigger = TriggerBuilder.Create()
    .WithIdentity("poll-inbox", "group1")
    .WithSimpleSchedule(x => x
        .WithInterval(TimeSpan.FromSeconds(30))
        .RepeatForever()
        // Thirty seconds after each run ends, however long it took.
        .MeasureIntervalFromCompletion())
    .Build();

• While a run is in progress, NextFireTimeUtc is provisional: the run's scheduled time plus the interval. The completion replaces it.
• A calendar moves the next run on by whole intervals past what it excludes.
• It holds this trigger only. The job's other triggers and TriggerJob still start beside it; use [DisallowConcurrentExecution] to hold the job.
• The [SimpleTrigger] attribute, the JSON Simple schedule and XML's <simple> carry it as MeasureIntervalFromCompletion and <measure-interval-from-completion>.
• A persistent store needs the 4.7 migration, add_trigger_fixed_delay_<db>.sql. A cluster measures from completion only once every node is 4.7 or later: an older node runs the trigger at a fixed rate.

A run missed while the scheduler was down has no backlog, because each run is measured from a completion:

Every instruction keeps to the end time and the repeat count.

SimpleTrigger Misfire Instructions

Misfires are explained in More About Triggers. SimpleTrigger's instructions are on the SimpleTriggerMisfireInstruction enum, whose API documentation describes each:

• SimpleTriggerMisfireInstruction.IgnoreMisfires
• SimpleTriggerMisfireInstruction.FireNow
• SimpleTriggerMisfireInstruction.NowWithExistingCount
• SimpleTriggerMisfireInstruction.NowWithRemainingCount
• SimpleTriggerMisfireInstruction.NextWithRemainingCount
• SimpleTriggerMisfireInstruction.NextWithExistingCount

SmartPolicy is available on every trigger and is the default. On a SimpleTrigger it resolves by repeat count:

FireNow on a repeating trigger is treated as NowWithRemainingCount, so the rest of the schedule is kept. The behaviour is in SimpleTriggerImpl.UpdateAfterMisfire.

Set the misfire instruction on the simple schedule (SimpleScheduleBuilder):

ITrigger trigger = TriggerBuilder.Create()
    .WithIdentity("trigger7", "group1")
    .WithSimpleSchedule(x => x
        .WithInterval(TimeSpan.FromMinutes(5))
        .RepeatForever()
        .WithMisfireInstruction(SimpleTriggerMisfireInstruction.NextWithExistingCount))
    .Build();