C# Academy · Lektion

Worker Service-projekter

Opret en selvstændig Worker Service, konfigurér DI og logning, og udrul den som Windows-tjeneste eller Linux-daemon.

Lektion 2 af 412 trin

Worker Service-projekter er en gratis C# Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i C# Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C# Academy-kurset indeholder 4 lektioner i alt.

Hvad er en Worker Service?

En Worker Service er en .NET-projektskabelon til opbygning af langvarige baggrundsapplikationer — uden webserver og HTTP-endepunkter. Det er en let værtsmodel, der er velegnet til købehandlere, planlagte opgaver og tjenester af dæmon-typen.

Oprettelse af en Worker Service

Brug CLI-skabelonen til at oprette et grundskelet til et Worker Service-projekt. Den genererer en minimal Program.cs og en Worker.cs-klasse, der nedarver fra 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

Den genererede Program.cs bruger den generiske vært. Du konfigurerer DI, logning og konfiguration og registrerer din worker — præcis som i ASP.NET Core, men uden webserveren.

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();

Worker-klassen

Nedarv fra BackgroundService, og implementér ExecuteAsync. Værten kalder den ved opstart og sender et annullerings-token, der aktiveres ved nedlukning.

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
}

Konfiguration og DI i workers

Worker Services understøtter hele .NET-konfigurationssystemet — appsettings, miljøvariabler og brugersecrets. Injicér IConfiguration eller indstillinger med stærke typer.

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);
        }
    }
}

Logning i Worker Services

Den generiske vært konfigurerer automatisk logning. Brug ILogger<T> til struktureret logning. I produktion kan du konfigurere Serilog, Application Insights eller en anden udbyder.

// 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);

Kørsel som Windows Service

Brug UseWindowsService() til at køre din Worker som en Windows Service. Tjenesten starter og stopper sammen med operativsystemet og fortsætter med at køre, når brugere logger ud.

// 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

Kørsel som en Linux-systemd-dæmon

Brug UseSystemd() til at integrere med systemd på Linux. Tjenesten modtager korrekte stop-signaler og integreres med logning via journald.

// 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

Kørsel i Docker

Worker Services er ideelle til Docker-containere — der er ikke behov for porttilknytning; kør blot processen i en løkke, indtil containeren stopper.

# 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]

Praktisk eksempel: baggrundsarbejder til e-mailoversigter

En komplet worker, der sender daglige e-mailoversigter ved at læse fra en database og sende dem via en e-mailtjeneste.

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"); }
        }
    }
}

Hurtigt tjek

Hvad er den vigtigste forskel mellem et Worker Service-projekt og et ASP.NET Core Web API-projekt?

Besvar den i den interaktive lektion

Opsummering: Worker Service-projekter

Vigtigste pointer:

Worker Service = generisk vært + BackgroundService, uden webserver
Fuld understøttelse af DI, logning og konfiguration — blot uden HTTP
UseWindowsService() til udrulning som Windows Service
UseSystemd() til en Linux-dæmon med journald-integration
Udrul i Docker-containere til cloud-native baggrundsbehandling
Brug altid IServiceScopeFactory til afhængigheder med afgrænset levetid i workeren

Gratis at komme i gang

Lær C# med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 93
Lektioner: 346

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Worker Service-projekter” gratis?

Ja — hele teksten til “Worker Service-projekter” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af C# Academy-kurset, skal du opgradere til CoddyKit PRO. C# Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Worker Service-projekter”?

Opret en selvstændig Worker Service, konfigurér DI og logning, og udrul den som Windows-tjeneste eller Linux-daemon. Du øver dig i C# Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på C# Academy?

Der kræves ingen tidligere erfaring. C# Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Worker Service-projekter”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne C# Academy-lektion?

Ja. Alle C# Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til C# Academy