C# Academy · Les

Worker Service-projecten

Maak een zelfstandige Worker Service, configureer DI en logging en deploy deze als Windows Service of Linux-daemon.

Les 2 van 412 stappen

Worker Service-projecten is een gratis C# Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C# Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C# Academy bevat in totaal 4 lessen.

Wat is een Worker Service?

Een Worker Service is een .NET-projectsjabloon voor het bouwen van langdurig draaiende achtergrondtoepassingen — zonder webserver en zonder HTTP-eindpunten. Het is een lichtgewicht host die ideaal is voor wachtrijverwerkers, geplande taken en services die als daemon werken.

Een Worker Service maken

Gebruik het CLI-sjabloon om een Worker Service-project te genereren. Dit maakt een minimale Program.cs en een klasse Worker.cs die overerft van BackgroundService.

# Create a new Worker Service project
dotnet new worker -n OrderProcessor

# Generated structure:
# OrderProcessor/
#   Program.cs       — host configuration
#   Worker.cs        — your BackgroundService subclass
#   appsettings.json

Worker Service Program.cs

Het gegenereerde Program.cs gebruikt de Generic Host. Je configureert afhankelijkheidsinjectie, logboekregistratie en configuratie en registreert je worker — net als in ASP.NET Core, maar zonder webserver.

using Microsoft.Extensions.Hosting;

var builder = Host.CreateApplicationBuilder(args);

// Register services
builder.Services.AddDbContext<AppDbContext>(opt =>
    opt.UseSqlServer(builder.Configuration.GetConnectionString("Default")));

builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddHostedService<OrderProcessorWorker>();

var host = builder.Build();
host.Run();

De klasse Worker

Erf over van BackgroundService en implementeer ExecuteAsync. De host roept deze aan bij het starten en geeft een annuleringstoken door dat wordt geactiveerd bij het afsluiten.

public class OrderProcessorWorker : BackgroundService
{
    private readonly IServiceScopeFactory _factory;
    private readonly ILogger<OrderProcessorWorker> _logger;

    public OrderProcessorWorker(
        IServiceScopeFactory factory,
        ILogger<OrderProcessorWorker> logger)
    {
        _factory = factory;
        _logger  = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            using var scope = _factory.CreateScope();
            var repo = scope.ServiceProvider.GetRequiredService<IOrderRepository>();
            var pending = await repo.GetPendingAsync(ct);
            foreach (var order in pending)
                await ProcessOrderAsync(order, ct);
            await Task.Delay(TimeSpan.FromSeconds(10), ct);
        }
    }

    private Task ProcessOrderAsync(Order o, CancellationToken ct) =>
        Task.Delay(100, ct); // placeholder
}

Configuratie en DI in workers

Worker Services ondersteunen het volledige .NET-configuratiesysteem — appsettings, omgevingsvariabelen en gebruikersgeheimen. Injecteer IConfiguration of sterk getypeerde opties.

builder.Services.Configure<WorkerSettings>(
    builder.Configuration.GetSection("Worker"));

public class OrderProcessorWorker : BackgroundService
{
    private readonly WorkerSettings _settings;

    public OrderProcessorWorker(IOptions<WorkerSettings> opts, ...)
        => _settings = opts.Value;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            // ...
            await Task.Delay(_settings.PollIntervalSeconds * 1000, ct);
        }
    }
}

Logboekregistratie in Worker Services

De Generic Host configureert logboekregistratie automatisch. Gebruik ILogger<T> voor gestructureerde logboekregistratie. Configureer in productie Serilog, Application Insights of een andere aanbieder.

// Add Serilog to a Worker Service
builder.Host.UseSerilog((ctx, logConfig) =>
    logConfig
        .ReadFrom.Configuration(ctx.Configuration)
        .WriteTo.Console()
        .WriteTo.Seq(ctx.Configuration["Seq:ServerUrl"]!));

// Structured logging in the worker:
_logger.LogInformation("Processing {Count} orders at {Time}",
    orders.Count, DateTimeOffset.UtcNow);
_logger.LogError(ex, "Failed to process order {OrderId}", order.Id);

Als Windows-service uitvoeren

Gebruik UseWindowsService() om je Worker als Windows-service uit te voeren. De service start en stopt samen met het besturingssysteem en blijft actief wanneer gebruikers zich afmelden.

// dotnet add package Microsoft.Extensions.Hosting.WindowsServices

builder.Services.AddWindowsService(options =>
    options.ServiceName = "OrderProcessor");

// Build and publish:
// dotnet publish -c Release -o ./publish

// Install as Windows Service:
// sc create OrderProcessor binpath="C:\services\publish\OrderProcessor.exe"
// sc start OrderProcessor

Als Linux Systemd-daemon uitvoeren

Gebruik UseSystemd() om met systemd op Linux te integreren. De service ontvangt de juiste stopsignalen en wordt geïntegreerd met journald-logboekregistratie.

// dotnet add package Microsoft.Extensions.Hosting.Systemd

builder.Services.AddSystemd();

// Systemd unit file: /etc/systemd/system/orderprocessor.service
// [Unit]
// Description=Order Processor Worker
// [Service]
// Type=notify
// ExecStart=/usr/bin/dotnet /app/OrderProcessor.dll
// Restart=always
// [Install]
// WantedBy=multi-user.target

// Commands:
// sudo systemctl enable orderprocessor
// sudo systemctl start orderprocessor
// sudo journalctl -u orderprocessor -f

In Docker uitvoeren

Worker Services zijn ideaal voor Docker-containers — poorttoewijzing is niet nodig; voer het proces gewoon uit in een lus totdat de container stopt.

# Dockerfile
FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app

FROM mcr.microsoft.com/dotnet/runtime:9.0
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "OrderProcessor.dll"]

# docker-compose.yml:
# services:
#   worker:
#     build: .
#     environment:
#       - ConnectionStrings__Default=Server=db;...
#     depends_on: [db]

Uit de praktijk: worker voor e-mailoverzichten

Een complete worker die dagelijkse e-mailoverzichten verstuurt door gegevens uit een database te lezen en ze via een e-mailservice te verzenden.

public class EmailDigestWorker : BackgroundService
{
    private readonly IServiceScopeFactory _factory;
    private readonly ILogger<EmailDigestWorker> _log;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        // Run daily at midnight UTC
        while (!ct.IsCancellationRequested)
        {
            var now = DateTime.UtcNow;
            var next = now.Date.AddDays(1); // next midnight
            await Task.Delay(next - now, ct);

            using var scope = _factory.CreateScope();
            var mailer = scope.ServiceProvider.GetRequiredService<IDigestMailer>();

            try   { await mailer.SendDailyDigestsAsync(ct); }
            catch (Exception ex) { _log.LogError(ex, "Digest failed"); }
        }
    }
}

Korte controle

Wat is het belangrijkste verschil tussen een Worker Service-project en een ASP.NET Core Web API-project?

Beantwoord dit in de interactieve les

Samenvatting: Worker Service-projecten

Belangrijkste punten:

Worker Service = Generic Host + BackgroundService, zonder webserver
Volledige ondersteuning voor afhankelijkheidsinjectie, logboekregistratie en configuratie — alleen geen HTTP
UseWindowsService() voor implementatie als Windows-service
UseSystemd() voor een Linux-daemon met journald-integratie
Implementeer in Docker-containers voor cloud-native achtergrondverwerking
Gebruik altijd IServiceScopeFactory voor afhankelijkheden met een beperkte levensduur in de worker

Gratis beginnen

Leer C# met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 93
Lessen: 346

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Worker Service-projecten” gratis?

Ja — de volledige tekst van “Worker Service-projecten” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C# Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C# Academy bevat in totaal 4 lessen.

Wat leer ik in “Worker Service-projecten”?

Maak een zelfstandige Worker Service, configureer DI en logging en deploy deze als Windows Service of Linux-daemon. Je oefent met C# Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C# Academy te beginnen?

Ervaring vooraf is niet nodig. C# Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Worker Service-projecten”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C# Academy?

Ja. Elke les over C# Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C# Academy