WorkR.Triggers.Timers 0.7.4

WorkR.Triggers.Timers

Timer-based triggers for WorkR, supporting fixed-delay and cron-scheduled background workers.

Installation

dotnet add package WorkR.Triggers.Timers

AddDelayWorker

Fires the pipeline repeatedly, waiting a fixed delay between the end of one execution and the start of the next.

Simple registration

builder.Services.AddDelayWorker<MyWorker>(TimeSpan.FromSeconds(30));

With startup execution

Run the pipeline immediately on host start, then continue on the delay interval:

builder.Services.AddDelayWorker<MyWorker>(TimeSpan.FromSeconds(30), runOnStartup: true);

With full pipeline control

builder.Services.AddDelayWorker(
    TimeSpan.FromSeconds(30),
    pipeline => pipeline
        .AddWorker<FetchWorker, IReadOnlyList<Item>>()
        .AddWorker<ProcessWorker>());

Each pipeline execution runs inside its own dependency injection scope, created automatically.

AddScheduledWorker

Fires the pipeline on a cron schedule. Standard five-field cron expressions are supported by default.

Simple registration

// Every 5 minutes
builder.Services.AddScheduledWorker<MyWorker>("*/5 * * * *");

// Every day at 9am
builder.Services.AddScheduledWorker<MyWorker>("0 9 * * *");

With startup execution

Run immediately on host start before the schedule takes over:

builder.Services.AddScheduledWorker<MyWorker>("0 9 * * *", runOnStartup: true);

With second-level precision

Enable six-field cron expressions (seconds field prepended):

// Every 30 seconds
builder.Services.AddScheduledWorker<MyWorker>("*/30 * * * * *", includeSeconds: true);

With overlap cancellation

Cancel a still-running execution when the next scheduled firing arrives:

builder.Services.AddScheduledWorker<MyWorker>("*/5 * * * *", cancelOnOverlap: true);

When cancelOnOverlap is true the previous execution's CancellationToken is cancelled before the new one starts. The old execution is not awaited — it drains in the background while the new one proceeds.

With full pipeline control

builder.Services.AddScheduledWorker(
    "0 * * * *",
    pipeline => pipeline
        .AddWorker<FetchWorker, IReadOnlyList<Item>>()
        .AddWorker<ProcessWorker>());

Each pipeline execution runs inside its own dependency injection scope, created automatically.

ScheduledTrigger fires worker executions on the thread pool so that a long-running execution does not delay the next scheduled firing.

Worker Interface

Both triggers use EmptyTriggerContext — time-based triggers carry no message payload.

public class MyWorker : IWorker<EmptyTriggerContext>
{
    private readonly ILogger<MyWorker> _logger;

    public MyWorker(ILogger<MyWorker> logger) => _logger = logger;

    public Task ExecuteAsync(EmptyTriggerContext context, CancellationToken cancellationToken)
    {
        _logger.LogInformation("Triggered at {timestamp} (execution {id})",
            context.OccurredAt, context.ExecutionId);
        return Task.CompletedTask;
    }
}