C# Academy · Leçon

Projets Worker Service

Créez un Worker Service autonome, configurez la DI et la journalisation, puis déployez-le comme service Windows ou démon Linux.

Projets Worker Service est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Qu’est-ce qu’un service Worker ?

Un service Worker est un modèle de projet .NET destiné à créer des applications d’arrière-plan de longue durée : pas de serveur web ni de endpoint HTTP. Il s’agit d’un hôte léger, parfaitement adapté aux processeurs de files d’attente, aux tâches planifiées et aux services de type démon.

Créer un service Worker

Utilisez le modèle CLI pour générer l’ossature d’un projet de service Worker. Il génère un Program.cs minimal et une classe Worker.cs qui hérite de 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 d’un service Worker

Le Program.cs généré utilise l’hôte générique. Vous configurez l’injection de dépendances, la journalisation, la configuration et l’enregistrement de votre service Worker, exactement comme dans ASP.NET Core, mais sans serveur 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

Héritez de BackgroundService et implémentez ExecuteAsync. L’hôte l’appelle au démarrage et lui transmet un jeton d’annulation qui se déclenche lors de l’arrêt.

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
}

Configuration et DI dans les services Worker

Les services Worker prennent en charge l’ensemble du système de configuration .NET : appsettings, variables d’environnement et secrets utilisateur. Injectez IConfiguration ou des options fortement typées.

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

Journalisation dans les services Worker

L’hôte générique configure automatiquement la journalisation. Utilisez ILogger<T> pour une journalisation structurée. En production, configurez Serilog, Application Insights ou un autre fournisseur.

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

Exécution en tant que service Windows

Utilisez UseWindowsService() pour exécuter votre service Worker en tant que service Windows. Le service démarre et s’arrête avec l’OS et continue de fonctionner après la déconnexion des utilisateurs.

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

Exécution en tant que démon Linux Systemd

Utilisez UseSystemd() pour intégrer votre application à systemd sous Linux. Le service reçoit les signaux d’arrêt appropriés et s’intègre à la journalisation 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

Exécution dans Docker

Les services Worker sont parfaitement adaptés aux conteneurs Docker : aucun mappage de port n’est nécessaire, il suffit d’exécuter le processus en boucle jusqu’à l’arrêt du conteneur.

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

Cas réel : service Worker de récapitulatifs d’e-mails

Un service Worker complet qui envoie des récapitulatifs quotidiens par e-mail en les lisant dans une base de données et en les distribuant via un service de messagerie.

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

Vérification rapide

Quelle est la principale différence entre un projet de service Worker et un projet d’API web ASP.NET Core ?

Récapitulatif : projets de services Worker

Points essentiels :

Service Worker = hôte générique + BackgroundService, sans serveur web
Prise en charge complète de DI, de la journalisation et de la configuration, mais pas de HTTP
UseWindowsService() pour déployer un service Windows
UseSystemd() pour un démon Linux intégré à journald
Déployez les services dans des conteneurs Docker pour le traitement d’arrière-plan infonuagique
Utilisez toujours IServiceScopeFactory pour les dépendances à portée du service Worker

Questions Fréquemment Posées

La leçon « Projets Worker Service » est-elle gratuite ?

Oui — le texte complet de « Projets Worker Service » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Projets Worker Service » ?

Créez un Worker Service autonome, configurez la DI et la journalisation, puis déployez-le comme service Windows ou démon Linux. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Projets Worker Service » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C# Academy