C# Academy · Lezione

Progetti Worker Service

Crei un Worker Service autonomo, configuri DI e logging e lo distribuisca come servizio Windows o demone Linux.

Progetti Worker Service è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Cos'è un Worker Service?

Un Worker Service è un modello di progetto .NET per creare applicazioni in background di lunga durata: non include un server web né endpoint HTTP. È un host leggero, ideale per processori di code, attività pianificate e servizi in stile daemon.

Creazione di un Worker Service

Utilizzi il modello CLI per creare lo scheletro di un progetto Worker Service. Il modello genera un Program.cs minimale e una classe Worker.cs che eredita da 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

Program.cs del Worker Service

Il Program.cs generato utilizza il Generic Host. È possibile configurare DI, logging e configurazione, oltre a registrare il worker, esattamente come in ASP.NET Core ma senza il server web.

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

La classe Worker

Erediti da BackgroundService e implementi ExecuteAsync. L'host lo chiama all'avvio e passa un token di annullamento che si attiva durante l'arresto.

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
}

Configurazione e DI nei worker

I Worker Service supportano il sistema di configurazione completo di .NET, inclusi appsettings, variabili d'ambiente e user secrets. Inserisca tramite injection IConfiguration oppure opzioni fortemente tipizzate.

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

Logging nei Worker Service

Il Generic Host configura automaticamente il logging. Utilizzi ILogger<T> per il logging strutturato. In produzione, configuri Serilog, Application Insights o un altro provider.

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

Esecuzione come servizio Windows

Utilizzi UseWindowsService() per eseguire il Worker come servizio Windows. Il servizio viene avviato e arrestato insieme al sistema operativo e continua a funzionare dopo la disconnessione degli utenti.

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

Esecuzione come daemon Linux Systemd

Utilizzi UseSystemd() per integrare il servizio con systemd su Linux. Il servizio riceve i corretti segnali di arresto e si integra con il logging di 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

Esecuzione in Docker

I Worker Service sono ideali per i container Docker: non è necessario alcun port mapping, basta eseguire il processo in un ciclo fino all'arresto del container.

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

Caso reale: worker per i riepiloghi email

Un worker completo che invia riepiloghi email giornalieri leggendo i dati da un database e inoltrandoli tramite un servizio email.

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

Verifica rapida

Qual è la differenza principale tra un progetto Worker Service e un progetto ASP.NET Core Web API?

Riepilogo: progetti Worker Service

Punti chiave:

Worker Service = Generic Host + BackgroundService, senza server web
Supporto completo per DI, logging e configurazione, ma non per HTTP
UseWindowsService() per la distribuzione come servizio Windows
UseSystemd() per un daemon Linux con integrazione con journald
Distribuisca i worker in container Docker per l'elaborazione in background cloud-native
Utilizzi sempre IServiceScopeFactory per le dipendenze scoped nel worker

Domande Frequenti

La lezione «Progetti Worker Service» è gratuita?

Sì — il testo completo di «Progetti Worker Service» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Progetti Worker Service»?

Crei un Worker Service autonomo, configuri DI e logging e lo distribuisca come servizio Windows o demone Linux. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Progetti Worker Service»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C# Academy