Planificateur de tâches en C# (.NET) : Quartz.NET et System.Threading.Timer

Planificateur de tâches en C# (.NET) : du simple minuteur au Quartz.NET industriel

Le planificateur de tâches (Task Scheduler) est une partie essentielle de toute application sérieuse. Qu'il s'agisse du nettoyage périodique du cache, de l'envoi de campagnes email ou de la synchronisation de données avec une API externe, un mécanisme fiable d'exécution d'opérations en arrière-plan est indispensable. Dans l'écosystème .NET, le développeur a accès à plusieurs approches : du System.Threading.Timer intégré au framework puissant et flexible Quartz.NET. Dans cet article, nous analyserons les deux options, montrerons des exemples de code et vous aiderons à choisir l'outil adapté à votre projet.

1. System.Threading.Timer intégré

Le moyen le plus simple et le plus léger de lancer une tâche planifiée est d'utiliser System.Threading.Timer. Il ne nécessite pas l'installation de packages tiers et est parfait pour des scénarios simples : exécuter une méthode à intervalles fixes ou avec un délai unique.

Exemple : exécution d'une tâche toutes les 5 secondes

using System;using System.Threading;

class Program{    static void Main()    {        // Création d'un minuteur qui lance le callback toutes les 5 secondes        Timer timer = new Timer(DoWork, null, TimeSpan.Zero, TimeSpan.FromSeconds(5));                Console.WriteLine("Minuteur démarré. Appuyez sur Entrée pour quitter.");        Console.ReadLine();                timer.Dispose();    }

    static void DoWork(object state)    {        Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] Exécution de la tâche d'arrière-plan...");    }}

Avantages :

• Intégré dans .NET, pas besoin de bibliothèques supplémentaires.
• Consommation minimale de ressources.
• Simplicité d'utilisation.

Inconvénients :

• Pas de support intégré des expressions CRON.
• Difficile de gérer plusieurs tâches avec des planifications différentes.
• Pas de mécanismes de persistance (les tâches sont perdues lors du redémarrage).
• Le callback s'exécute dans un thread du pool, des problèmes de synchronisation possibles.

Pour les projets d'apprentissage et les utilitaires simples, System.Threading.Timer est un excellent choix. Cependant, pour les applications de production avec des dizaines de tâches, il vaut mieux se tourner vers des solutions plus avancées.

2. Quartz.NET — planificateur de tâches industriel

Quartz.NET est un framework puissant, flexible et mature pour la planification de tâches en .NET. Il s'inspire du populaire équivalent Java Quartz et prend en charge :

• Les expressions CRON pour une planification flexible (toutes les deux heures, en semaine à 9h00, etc.).
• La persistance des tâches (sauvegarde en base de données).
• Le clustering (plusieurs serveurs peuvent exécuter des tâches).
• La gestion des tâches manquées (misfire handling).
• Les tâches filles et les déclencheurs.

Installation de Quartz.NET

Installez le package via NuGet :

dotnet add package Quartz

Exemple : tâche simple avec planification CRON

using System;using System.Threading.Tasks;using Quartz;using Quartz.Impl;

class Program{    static async Task Main()    {        // Création du planificateur        StdSchedulerFactory factory = new StdSchedulerFactory();        IScheduler scheduler = await factory.GetScheduler();        await scheduler.Start();

        // Définition de la tâche (Job)        IJobDetail job = JobBuilder.Create<HelloJob>()            .WithIdentity("helloJob", "group1")            .Build();

        // Création du déclencheur : tous les jours à 10h30 du matin        ITrigger trigger = TriggerBuilder.Create()            .WithIdentity("trigger1", "group1")            .WithCronSchedule("0 30 10 ? * * *")  // CRON : seconde, minute, heure, jour, mois, jour de la semaine            .Build();

        // Enregistrement de la tâche avec le déclencheur        await scheduler.ScheduleJob(job, trigger);

        Console