RepletoryLib.Workers 1.0.0

RepletoryLib.Workers

Base classes for polling, queue-based, and cron-scheduled background workers.

Part of the RepletoryLib ecosystem -- standalone, reusable .NET 10 libraries with zero business logic.

Overview

RepletoryLib.Workers provides three abstract base classes for building long-running background services in ASP.NET Core. Each base class handles the execution loop, error handling, and timing -- you just implement the core logic.

Key Features

• PollingWorkerBase -- Execute logic at fixed intervals (e.g., every 60 seconds)
• QueueWorkerBase<T> -- Process items from an in-memory queue with backpressure
• ScheduledWorkerBase -- Execute on a cron schedule with next-run calculation
• Error resilience -- Exceptions are caught and logged; workers continue running
• Configurable -- Interval, concurrency, and cron expression via WorkerOptions

Installation

dotnet add package RepletoryLib.Workers

Dependencies

Usage Examples

Polling Worker

Runs logic at a fixed interval:

using RepletoryLib.Workers;

public class StaleOrderCleanupWorker : PollingWorkerBase
{
    private readonly IServiceScopeFactory _scopeFactory;

    public StaleOrderCleanupWorker(ILogger<StaleOrderCleanupWorker> logger, IServiceScopeFactory scopeFactory)
        : base(logger, new WorkerOptions { IntervalSeconds = 300 }) // Every 5 minutes
    {
        _scopeFactory = scopeFactory;
    }

    protected override async Task ExecuteOnTickAsync(CancellationToken cancellationToken)
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();

        var staleOrders = await db.Orders
            .Where(o => o.Status == OrderStatus.Pending && o.CreatedAt < DateTime.UtcNow.AddHours(-2))
            .ToListAsync(cancellationToken);

        foreach (var order in staleOrders)
            order.Status = OrderStatus.Cancelled;

        await db.SaveChangesAsync(cancellationToken);
    }
}

// Register:
builder.Services.AddHostedService<StaleOrderCleanupWorker>();

Queue Worker

Processes items from an in-memory queue:

using RepletoryLib.Workers;

public class EmailQueueWorker : QueueWorkerBase<EmailMessage>
{
    private readonly IEmailService _email;

    public EmailQueueWorker(ILogger<EmailQueueWorker> logger, IEmailService email)
        : base(logger, new WorkerOptions { MaxConcurrency = 3 })
    {
        _email = email;
    }

    protected override async Task ProcessAsync(EmailMessage item, CancellationToken cancellationToken)
    {
        await _email.SendAsync(item.To, item.Subject, item.Body);
    }
}

// Enqueue items from anywhere:
var worker = app.Services.GetRequiredService<EmailQueueWorker>();
await worker.EnqueueAsync(new EmailMessage { To = "user@example.com", Subject = "Hello" });

Scheduled Worker (Cron)

Runs on a cron schedule:

using RepletoryLib.Workers;

public class NightlyReportWorker : ScheduledWorkerBase
{
    public NightlyReportWorker(ILogger<NightlyReportWorker> logger)
        : base(logger, new WorkerOptions { CronExpression = "0 2 * * *" }) // 2 AM daily
    {
    }

    protected override async Task ExecuteJobAsync(CancellationToken cancellationToken)
    {
        // Generate nightly report
        await _reportService.GenerateAsync(DateTime.UtcNow.AddDays(-1));
    }
}

API Reference

WorkerOptions

Integration with Other RepletoryLib Packages

License

This project is licensed under the MIT License.

Copyright (c) 2024-2026 Repletory.

For complete documentation, infrastructure setup, and configuration reference, see the RepletoryLib main repository.