MinimalWorker 2.0.2

MinimalWorker

MinimalWorker is a lightweight .NET library that simplifies background worker registration in ASP.NET Core and .NET applications using the IHost interface. It offers three simple extension methods to map background tasks that run continuously or periodically, with support for dependency injection and cancellation tokens.

✨ Features

• 🚀 Register background workers with a single method call
• ⏱ Support for periodic background tasks
• 🔄 Built-in support for CancellationToken
• 🧪 Works seamlessly with dependency injection (IServiceProvider)
• 🧼 Minimal and clean API

📦 Installation

Install from NuGet:

dotnet add package MinimalWorker

Or via the NuGet Package Manager:

Install-Package MinimalWorker

🛠 Usage

Continuous Background Worker

app.RunBackgroundWorker(async (MyService service, CancellationToken token) =>
{
    while (!token.IsCancellationRequested)
    {
        await service.DoWorkAsync();
        await Task.Delay(1000, token);
    }
});

Periodic Background Worker

app.RunPeriodicBackgroundWorker(TimeSpan.FromMinutes(5), async (MyService service, CancellationToken token) =>
{
    await service.CleanupAsync();
});

Command run on notice (Cron) Background Worker

app.RunCronBackgroundWorker("0 0 * * *", async (CancellationToken ct, MyService service) =>
{
    await service.SendDailyProgressReport();
});

All methods automatically resolve services from the DI container and inject the CancellationToken if it's a parameter.

Workers are automatically initialized and started when the application starts - no additional calls needed!

🔧 How It Works

• RunBackgroundWorker runs a background task once the application starts, and continues until shutdown.
• RunPeriodicBackgroundWorker runs your task repeatedly at a fixed interval using PeriodicTimer.
• RunCronBackgroundWorker runs your task repeatedly based on a CRON expression (UTC time), using NCrontab for timing.
• Workers are initialized using source generators for AOT compatibility - no reflection at runtime!
• Workers automatically start when the application starts via lifetime.ApplicationStarted.Register()
• Services and parameters are resolved per execution using CreateScope() to support scoped dependencies.

🚀 AOT Compilation Support

MinimalWorker is fully compatible with .NET Native AOT compilation! The library uses source generators instead of reflection, making it perfect for AOT scenarios.

Publishing as AOT

To publish your application as a native AOT binary:

dotnet publish -c Release

Make sure your project file includes:

<PropertyGroup>
  <PublishAot>true</PublishAot>
</PropertyGroup>

This will produce a self-contained native executable with:

• No .NET runtime dependency - runs on machines without .NET installed
• Fast startup - native code execution from the start
• Small binary size - approximately 4-5MB for a minimal application
• AOT-safe - all worker registration happens via source generators, no reflection

See the MinimalWorker.Aot.Sample project for a complete example.