Files d'attente de tâches en C# (.NET) : aperçu des bibliothèques et implémentations

Files d'attente de tâches pour C# (.NET) : des primitives de base aux solutions industrielles

L'organisation du traitement asynchrone des tâches est l'une des tâches clés lors du développement d'applications à forte charge en C#. Dans l'écosystème .NET, il existe plusieurs approches : des primitives de synchronisation intégrées aux puissantes bibliothèques externes. Dans cet article, nous examinerons les principaux outils pour travailler avec les files d'attente de tâches, leurs points forts et des exemples d'utilisation.

1. System.Threading.Channels — outil intégré .NET

Depuis .NET Core 2.1, la bibliothèque standard inclut la classe System.Threading.Channels.Channel<T>. Il s'agit d'une file d'attente thread-safe, optimisée pour les scénarios producteur-consommateur.

Fonctionnalités principales :

• Lecture et écriture asynchrones (WriteAsync, ReadAsync)
• Prise en charge des files d'attente limitées et illimitées
• Possibilité de finaliser la file d'attente pour signaler aux consommateurs
• Haute performance sans verrouillage

Exemple d'utilisation :

using System.Threading.Channels;

var channel = Channel.CreateBounded<string>(100);

// Producteurvar producer = Task.Run(async () =>{    for (int i = 0; i < 10; i++)    {        await channel.Writer.WriteAsync($"Task {i}");        await Task.Delay(100);    }    channel.Writer.Complete();});

// Consommateurvar consumer = Task.Run(async () =>{    await foreach (var item in channel.Reader.ReadAllAsync())    {        Console.WriteLine($"Processing: {item}");        await Task.Delay(200);    }});

await Task.WhenAll(producer, consumer);

Quand l'utiliser : pour les files d'attente internes dans un seul processus, lorsque la persistance ou le traitement distribué ne sont pas nécessaires.

2. Hangfire — bibliothèque avancée de tâches d'arrière-plan

Hangfire est l'une des bibliothèques les plus populaires pour la gestion des tâches d'arrière-plan en .NET. Elle prend en charge les files d'attente, la planification, les tentatives et la surveillance.

Caractéristiques clés :

• Persistance (SQL Server, Redis, PostgreSQL, etc.)
• Interface web pour la surveillance
• Prise en charge des tâches différées et récurrentes
• Tentatives automatiques en cas d'échec

Exemple de configuration et d'utilisation :

// Installation : Install-Package Hangfire// Dans Startup.cspublic void ConfigureServices(IServiceCollection services){    services.AddHangfire(config =>        config.UseSqlServerStorage(connectionString));    services.AddHangfireServer();}

// Utilisationpublic class EmailService{    public void SendWelcomeEmail(int userId)    {        // Logique d'envoi d'email        Console.WriteLine($"Sending email to user {userId}");    }}

// Mise en file d'attente de la tâcheBackgroundJob.Enqueue<EmailService>(x => x.SendWelcomeEmail(42));

// Tâche différéeBackgroundJob.Schedule<EmailService>(    x => x.SendWelcomeEmail(43),     TimeSpan.FromMinutes(5));

Quand l'utiliser : pour les applications web où la conservation des tâches entre les redémarrages, la surveillance et la planification flexible sont nécessaires.

3. RabbitMQ.Client — file d'attente de messages distribuée

Pour les systèmes distribués où plusieurs services doivent échanger des tâches, RabbitMQ est utilisé. La bibliothèque RabbitMQ.Client fournit un accès complet au protocole AMQP.

Exemple de base producteur-consommateur :

using RabbitMQ.Client;using System.Text;

// Producteurvar factory = new ConnectionFactory() { HostName = "localhost" };using var connection = factory.CreateConnection();using var channel = connection.CreateModel();

channel.QueueDeclare(queue: "task_queue",                     durable: true,                     exclusive