WorkR

WorkR is a lightweight, extensible .NET library for building composable background worker pipelines on top of BackgroundService. It replaces deeply nested loops and ad-hoc polling logic with a clean, testable, and DI-friendly abstraction.

---

The Problem

Building background workers in .NET typically results in boilerplate-heavy BackgroundService implementations with nested loops, scattered error handling, and logic that is difficult to test in isolation:

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    while (!stoppingToken.IsCancellationRequested)
    {
        try
        {
            var results = await _repository.QueryAsync();
            foreach (var result in results)
            {
                await _processor.ProcessAsync(result);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Worker failed.");
        }

        await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
    }
}

WorkR solves this by separating concerns into discrete, composable pieces — triggers, workers, and middleware — each with a single responsibility.

---

Concepts

Concept	Role
Trigger	Owns the execution loop. Fires the worker pipeline on a timer, queue message, or any signal.
Worker	Receives a value from the trigger (or a previous worker) and performs work.
Middleware	Wraps worker execution with cross-cutting concerns (error handling, timeouts, scoping).
TriggerContext	The typed payload passed from trigger to worker chain, carrying metadata like ExecutionId and OccurredAt.

---

Quick Start

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("Running at {timestamp}", context.OccurredAt);
        return Task.CompletedTask;
    }
}

// Run once on startup
builder.Services.AddRunOnceWorker<MyWorker>();

// Run on a fixed delay
builder.Services.AddDelayWorker<MyWorker>(TimeSpan.FromSeconds(30));

// Run on a cron schedule
builder.Services.AddScheduledWorker<MyWorker>("*/5 * * * *");

---

Packages

Package	Description
WorkR.Abstractions	Core interfaces: ITrigger<T>, IWorker<T>, IWorkerMiddleware, TriggerContext. Reference this from libraries that define reusable workers, triggers, or middleware.
WorkR	Core implementation: pipeline builder, built-in middleware, AddWorker, AddRunOnceWorker.
WorkR.Triggers.Timers	Delay and cron-scheduled triggers: AddDelayWorker, AddScheduledWorker.
WorkR.Triggers.AzureStorageQueues	Azure Storage Queue trigger: AddStorageQueueWorker.
WorkR.Triggers.AzureServiceBus	Azure Service Bus trigger: AddServiceBusWorker.

---

License

MIT