Programmation réactive en C# (.NET)

Programmation réactive en C# (.NET) : Observable, Rx.NET et travail avec les flux de données

La programmation réactive (Reactive Programming) est un paradigme orienté vers le traitement asynchrone des flux de données et la propagation des changements. Dans l'écosystème C# (.NET), ce concept est implémenté via la bibliothèque Rx.NET (Reactive Extensions) et les interfaces IObservable<T> / IObserver<T>. Contrairement à l'approche impérative classique, la programmation réactive permet de décrire de manière déclarative comment le système doit réagir aux événements, sans bloquer le thread d'exécution principal.

Sur la page PythonLib, nous examinerons les composants clés de la programmation réactive en C#, y compris les séquences Observable, les opérateurs LINQ pour la transformation des flux et des exemples pratiques d'utilisation.

Concepts fondamentaux de la programmation réactive en C#

La programmation réactive est basée sur le modèle Observer, où :

Observable — la source de données (flux d'événements).
Observer — l'abonné qui réagit aux données entrantes.
Subscription — le mécanisme de gestion de l'abonnement (désabonnement du flux).

Dans .NET, ces concepts sont représentés par les interfaces IObservable<T> et IObserver<T>, mais en pratique, on utilise plus souvent la bibliothèque Rx.NET (package NuGet System.Reactive), qui fournit un riche ensemble d'opérateurs pour travailler avec les séquences.

Installation de Rx.NET

Pour commencer, ajoutez le package NuGet à votre projet :

Install-Package System.Reactive

Ou via .NET CLI :

dotnet add package System.Reactive

Création d'un Observable et abonnement à un flux de données

Considérons un exemple simple : créons un Observable qui génère des nombres de 1 à 5 avec un délai, et abonnons-nous à celui-ci.

using System;using System.Reactive.Linq;using System.Threading.Tasks;

class Program{    static async Task Main()    {        // Créer une séquence Observable        var observable = Observable.Interval(TimeSpan.FromSeconds(1))            .Select(x => x + 1) // Commencer à 1            .Take(5);           // Prendre seulement 5 éléments

        // S'abonner au flux        var subscription = observable.Subscribe(            onNext: value => Console.WriteLine($"Reçu : {value}"),            onError: error => Console.WriteLine($"Erreur : {error.Message}"),            onCompleted: () => Console.WriteLine("Flux terminé")        );

        // Attendre la fin (dans du code réel, utilisez await ou un verrou)        await Task.Delay(6000);

        // Se désabonner (libérer les ressources)        subscription.Dispose();    }}

Opérateurs LINQ pour la transformation des flux

L'un des principaux avantages de Rx.NET est la possibilité d'appliquer aux flux de données des opérateurs familiers de LINQ : Where, Select, Aggregate et autres. Cela permet de décrire les transformations de manière déclarative.

Exemple : filtrage et transformation

using System;using System.Reactive.Linq;

var numbers = Observable.Range(1, 10);

var processed = numbers    .Where(n => n % 2 == 0)    // Uniquement les pairs    .Select(n => n * n)        // Élever au carré    .Do(n => Console.WriteLine($"Traité : {n}")); // Effet secondaire

processed.Subscribe(    onNext: n => Console.WriteLine($"Résultat : {n}"),    onCompleted: () => Console.WriteLine("Terminé"));