FR
RU
EN
ES
ZH
DE
PT
AR
HI
Files d'attente de tâches pour C# (.NET) : du simple au complexe
Le développement moderne en C# (.NET) se passe rarement de tâches d'arrière-plan, de traitement différé et d'opérations asynchrones. Les files d'attente de tâches (Job Queues / Message Queues) sont un modèle clé permettant de décharger le thread principal de l'application, de garantir la livraison des messages et de dimensionner le traitement. Dans cet article, nous examinons trois approches populaires pour implémenter des files d'attente dans .NET : le System.Threading.Channels intégré, le puissant planificateur Hangfire et le courtier de messages industriel RabbitMQ avec son client .NET.
1. System.Threading.Channels — file d'attente intégrée dans .NET
System.Threading.Channels est une file d'attente légère et thread-safe, disponible directement dans .NET (depuis .NET Core 2.1). Elle est idéale pour les scénarios « producteur-consommateur » au sein d'un même processus.
Fonctionnalités principales :
- Lecture et écriture asynchrones (
await writer.WriteAsync(),await reader.ReadAsync()). - Canaux limités et illimités (Bounded / Unbounded).
- Prise en charge de l'annulation via
CancellationToken. - Lecture par lots (
ReadAllAsync).
Exemple : file d'attente de tâches simple
using System.Threading.Channels;
// Création d'un canal avec un tampon de 100 élémentsvar channel = Channel.CreateBounded<string>(100);
// Producteur : ajout de tâchesvar producer = Task.Run(async () =>{ for (int i = 0; i < 10; i++) { await channel.Writer.WriteAsync($"Tâche {i}"); await Task.Delay(100); } channel.Writer.Complete(); // signal de fin});
// Consommateur : traitement des tâchesvar consumer = Task.Run(async () =>{ await foreach (var item in channel.Reader.ReadAllAsync()) { Console.WriteLine($"Traitée : {item}"); }});
await Task.WhenAll(producer, consumer);Avantages : zéro dépendance, haute performance, idéal pour les files d'attente en mémoire dans une seule application.
Inconvénients : ne convient pas aux systèmes distribués — les données sont perdues lors du redémarrage.
2. Hangfire — planificateur avancé de tâches d'arrière-plan
Hangfire est une bibliothèque populaire pour .NET qui non seulement implémente une file d'attente, mais fournit également un tableau de bord web, la persistance (SQL Server, Redis, PostgreSQL), les tentatives automatiques et les planifications CRON.
Fonctionnalités clés :
- Fire-and-forget (exécution unique).
- Tâches différées (Delayed).
- Tâches récurrentes (Recurring) — remplacement du Planificateur de tâches Windows.
- Nouvelles tentatives automatiques avec politique configurable.
- Surveillance intégrée (tableau de bord).
Exemple : configuration de base de Hangfire
// Installation : Install-Package Hangfireusing Hangfire;using Hangfire.SqlServer;
// Configuration dans Program.cs (.NET 6+)var builder = WebApplication.CreateBuilder(args);builder.Services.AddHangfire(config => config.UseSqlServerStorage(builder.Configuration.GetConnectionString("HangfireDb")));builder.Services.AddHangfireServer();
var app = builder.Build();app.UseHangfireDashboard(); // /hangfire
// Ajout de tâchesBackgroundJob.Enqueue(() => Console.WriteLine("Fire-and-forget !"));BackgroundJob.Schedule(() => Console.WriteLine("Dans 5 minutes"), TimeSpan.FromMinutes(5));RecurringJob.AddOrUpdate("my-job", () => Console.WriteLine("Chaque minute"), Cron.Minutely);
app.Run();Avantages : fonctionnalités riches, conservation de l'état entre les redémarrages, interface utilisateur prête.
Inconvénients : nécessite une base de données, ne convient pas aux systèmes distribués à forte charge (conçu pour le monolithe).
3. RabbitMQ + .NET — file d'attente de messages distribuée
RabbitMQ
Aussi dans la bibliothèque
Recommendations
