Fluent.Hosting 1.0.0

Fluent.Hosting

Created in Poland by Leszek Pomianowski and open-source community.
Small fluent extensions for registering inline hosted services in .NET dependency injection.

Getting started

dotnet add package Fluent.Hosting

https://www.nuget.org/packages/Fluent.Hosting

using Fluent.Hosting;

builder.Services.AddHostedService<IMigrator>(async (migrator, token) =>
{
    await migrator.MigrateAsync(token);
});

The package registers delegates as IHostedService instances. Use it when a startup or background task is simple enough that a dedicated hosted service class would add noise.

Choosing an extension

All registrations are singleton IHostedService registrations. Multiple calls add multiple hosted services; each delegate runs.

Hosted services

Use AddHostedService when the delegate can use singleton services or the root service provider directly.

builder.Services.AddHostedService(async (services, token) =>
{
    var cache = services.GetRequiredService<IProductCache>();

    await cache.WarmAsync(token);
});

You can also ask Fluent.Hosting to resolve the service for you:

builder.Services.AddHostedService<IProductCache>(async (cache, token) =>
{
    await cache.WarmAsync(token);
});

AddHostedService waits for the delegate to complete during host startup.

Scoped hosted services

Use AddScopedHostedService when the work needs scoped dependencies.

builder.Services.AddScopedHostedService<IDocumentSession>(async (session, token) =>
{
    session.Store(new MyData());

    await session.SaveChangesAsync(token);
});

The service creates a scope for the delegate, resolves IDocumentSession from that scope, and disposes the scope after the delegate completes.

Background services

Use AddBackgroundService when the delegate should run as a BackgroundService.

builder.Services.AddBackgroundService<IQueueWorker>(async (worker, token) =>
{
    await worker.RunAsync(token);
});

You can also access the provider directly:

builder.Services.AddBackgroundService(async (services, token) =>
{
    var worker = services.GetRequiredService<IQueueWorker>();

    await worker.RunAsync(token);
});

Scoped background services

Use AddScopedBackgroundService when background work needs scoped dependencies.

builder.Services.AddScopedBackgroundService<IDocumentSession>(async (session, token) =>
{
    var pending = await session.Query<PendingJob>().ToListAsync(token);

    foreach (PendingJob job in pending)
    {
        job.MarkStarted();
    }

    await session.SaveChangesAsync(token);
});

The scope remains alive until the async delegate completes.

Cancellation tokens

Every extension has two delegate shapes:

builder.Services.AddHostedService<IWorker>(worker => worker.RunAsync());

builder.Services.AddHostedService<IWorker>((worker, token) => worker.RunAsync(token));

Use the token-aware overload for I/O, database work, queues, or anything that should stop promptly during shutdown or cancelled startup.

Multiple registrations

Each call registers a separate hosted service. They are started by the host in registration order.

builder.Services.AddHostedService<IClockSetup>((setup, token) => setup.InitializeAsync(token));
builder.Services.AddScopedHostedService<IDocumentSession>((session, token) => session.SaveChangesAsync(token));
builder.Services.AddBackgroundService<IQueueWorker>((worker, token) => worker.RunAsync(token));

License

Fluent.Hosting is free and open source software licensed under the MIT License. You can use it in private and commercial projects.
Keep in mind that you must include a copy of the license in your project.