{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Qu'est-ce que l'interface IObservable dans Reactive Extensions (Rx.NET) ?","acceptedAnswer":{"@type":"Answer","text":"IObservable est l'interface fondamentale de Rx.NET qui représente une source de données push. Elle expose une méthode Subscribe permettant aux observateurs de s'abonner pour recevoir des notifications asynchrones. C'est le pendant réactif de IEnumerable : alors que IEnumerable pull les données de manière synchrone, IObservable push les données de manière asynchrone vers les abonnés."}},{"@type":"Question","name":"Quelles sont les trois méthodes de l'interface IObserver en Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"IObserver définit trois méthodes : OnNext(T value) pour recevoir chaque élément de la séquence, OnError(Exception error) pour gérer les erreurs et signaler la fin de la séquence en cas d'échec, et OnCompleted() pour indiquer que la séquence s'est terminée avec succès. Ces trois méthodes forment le contrat observer qui garantit qu'après OnError ou OnCompleted, aucun autre OnNext ne sera appelé."}},{"@type":"Question","name":"Quelle est la différence principale entre IEnumerable et IObservable ?","acceptedAnswer":{"@type":"Answer","text":"IEnumerable est un modèle pull où le consommateur demande les données de manière synchrone avec GetEnumerator() et MoveNext(). IObservable est un modèle push où la source pousse les données de manière asynchrone vers les abonnés via Subscribe(). IEnumerable bloque le thread appelant lors de l'itération, tandis que IObservable permet des opérations non-bloquantes et la composition d'événements asynchrones avec des opérateurs LINQ."}},{"@type":"Question","name":"Quel est le rôle de l'opérateur Select dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"Select est un opérateur de transformation qui projette chaque élément d'une séquence observable en une nouvelle forme en appliquant une fonction. C'est l'équivalent réactif de LINQ Select pour IEnumerable. Par exemple, observable.Select(x => x * 2) multiplie chaque valeur par 2. Select préserve l'ordre et le timing des émissions tout en transformant les valeurs, et il propage les erreurs et la complétion de la source."}},{"@type":"Question","name":"Comment l'opérateur Where fonctionne-t-il dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"Where est un opérateur de filtrage qui ne transmet que les éléments d'une séquence observable satisfaisant un prédicat spécifié. Il applique une fonction booléenne à chaque élément et émet uniquement ceux pour lesquels elle retourne true. L'opérateur maintient l'ordre des éléments, préserve le timing relatif des émissions, et propage automatiquement OnError et OnCompleted de la source vers les abonnés en aval."}},{"@type":"Question","name":"Qu'est-ce qu'un Subject en Rx.NET et quand l'utiliser ?","acceptedAnswer":{"@type":"Answer","text":"Subject est une classe qui implémente à la fois IObservable et IObserver, agissant comme un pont entre les deux. Il permet de pousser manuellement des valeurs avec OnNext() tout en servant de source observable à laquelle des observateurs peuvent s'abonner. Utiliser Subject lorsqu'il faut convertir du code impératif en séquence observable, ou pour multicaster manuellement des événements vers plusieurs abonnés. Attention aux fuites mémoire si les abonnements ne sont pas disposés."}},{"@type":"Question","name":"Quelle est la différence entre BehaviorSubject et Subject ?","acceptedAnswer":{"@type":"Answer","text":"BehaviorSubject stocke la dernière valeur émise et la réémet immédiatement aux nouveaux abonnés, garantissant qu'ils reçoivent toujours une valeur initiale. Il nécessite une valeur initiale au moment de la construction. Subject n'a pas de mémoire : les nouveaux abonnés ne reçoivent que les valeurs émises après leur abonnement. Utiliser BehaviorSubject pour représenter un état actuel comme un état de connexion utilisateur, et Subject pour de simples flux d'événements."}},{"@type":"Question","name":"À quoi sert l'opérateur SelectMany dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"SelectMany (aussi appelé FlatMap) projette chaque élément d'une séquence observable en une nouvelle séquence observable, puis aplatit toutes les séquences résultantes en une seule séquence. C'est essentiel pour gérer des opérations asynchrones imbriquées : par exemple, pour chaque utilisateur, faire un appel API asynchrone et fusionner tous les résultats. SelectMany permet également de composer des opérations dépendantes et gère automatiquement la concurrence des observables internes."}},{"@type":"Question","name":"Quel est le rôle de l'opérateur Merge dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"Merge combine plusieurs séquences observables en une seule séquence en entrelacant leurs émissions dans l'ordre temporel d'arrivée. Les éléments de toutes les sources sont transmis dès qu'ils arrivent, sans attendre les autres sources. La séquence résultante se termine quand toutes les sources ont complété. Si une source émet OnError, l'erreur est propagée immédiatement et toutes les autres sources sont désabonnées. Merge est utile pour combiner des flux d'événements indépendants comme plusieurs WebSockets."}},{"@type":"Question","name":"Comment fonctionne l'opérateur Buffer dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"Buffer accumule les éléments d'une séquence observable dans des listes et émet chaque liste complète selon un critère spécifié : taille fixe, intervalle de temps, ou signal d'une autre observable. Par exemple, Buffer(10) groupe par paquets de 10 éléments, ou Buffer(TimeSpan.FromSeconds(5)) groupe les éléments arrivés durant 5 secondes. C'est utile pour le traitement par lots, la réduction de fréquence de notifications, ou l'agrégation de données avant traitement."}},{"@type":"Question","name":"Quelle est la différence entre une observable Hot et une observable Cold ?","acceptedAnswer":{"@type":"Answer","text":"Une observable Cold commence à émettre uniquement quand un observateur s'abonne et chaque abonné reçoit sa propre séquence complète depuis le début. Exemple : Observable.Range(1, 10). Une observable Hot émet indépendamment des abonnements et tous les abonnés partagent la même séquence en cours. Les nouveaux abonnés ne voient que les événements futurs. Exemple : Subject, événements UI, ou flux en temps réel. Utiliser Publish() ou Share() pour convertir Cold en Hot."}},{"@type":"Question","name":"Qu'est-ce qu'un IScheduler dans Rx.NET et à quoi sert-il ?","acceptedAnswer":{"@type":"Answer","text":"IScheduler est une abstraction qui contrôle où et quand les actions Rx sont exécutées. Il détermine le contexte d'exécution (thread) et le timing des opérations asynchrones. IScheduler expose des méthodes Schedule pour planifier des actions immédiatement, avec délai, ou à un moment précis. Il permet de contrôler la concurrence, éviter les deadlocks, et tester le code temporel de manière déterministe avec TestScheduler. Les schedulers courants incluent CurrentThreadScheduler, ThreadPoolScheduler, et EventLoopScheduler."}},{"@type":"Question","name":"Quand utiliser ThreadPoolScheduler dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"ThreadPoolScheduler exécute les actions Rx sur des threads du ThreadPool .NET, adapté pour des opérations CPU-bound courtes et parallélisables. Utiliser pour déléguer du travail hors du thread UI ou du thread principal afin d'éviter les blocages. Exemple : Observable.Range(1, 100, Scheduler.ThreadPool) génère les valeurs sur un thread pool. Attention aux race conditions et à la synchronisation quand plusieurs observables partagent un état mutable. Ne pas l'utiliser pour des opérations I/O-bound longues qui peuvent saturer le pool."}},{"@type":"Question","name":"Comment l'opérateur Delay fonctionne-t-il dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"Delay décale temporellement toutes les notifications d'une séquence observable d'une durée spécifiée. Il utilise un scheduler pour planifier les émissions retardées sur un thread approprié. Par exemple, observable.Delay(TimeSpan.FromSeconds(2)) émet chaque valeur 2 secondes après son émission originale, préservant l'espacement relatif entre les éléments. Delay préserve également l'ordre des émissions et propage OnCompleted et OnError avec le même délai. Utile pour implémenter des timeouts, débouncing, ou simulation de latence réseau."}},{"@type":"Question","name":"Qu'est-ce que ReplaySubject et quand l'utiliser ?","acceptedAnswer":{"@type":"Answer","text":"ReplaySubject est un Subject qui mémorise N dernières valeurs (ou toutes les valeurs, ou celles émises dans une fenêtre temporelle) et les rejoue immédiatement aux nouveaux abonnés. Exemple : ReplaySubject(3) rejoue les 3 dernières valeurs. Utile pour des scénarios de cache, logs d'événements, ou synchronisation d'état pour les abonnés tardifs. Attention à la consommation mémoire si trop de valeurs sont stockées. Différent de BehaviorSubject qui ne stocke que la dernière valeur."}},{"@type":"Question","name":"À quoi sert l'opérateur Throttle (ou Sample) dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"Throttle émet uniquement le dernier élément d'une séquence observable après une période d'inactivité spécifiée, ignorant tous les éléments intermédiaires émis trop rapidement. C'est utile pour gérer les événements haute fréquence comme la saisie utilisateur dans une barre de recherche : attendre 300ms d'inactivité avant de lancer une requête API. Sample est similaire mais émet périodiquement le dernier élément selon un intervalle fixe. Ces opérateurs réduisent drastiquement la charge en filtrant les émissions redondantes."}},{"@type":"Question","name":"Comment gérer les erreurs dans une séquence observable avec Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"Rx.NET offre plusieurs opérateurs pour gérer les erreurs : Catch pour intercepter une exception et basculer vers une observable de secours, Retry pour réessayer automatiquement N fois en cas d'erreur, OnErrorResumeNext pour continuer avec une autre observable après erreur. Il est possible de gérer les erreurs dans Subscribe avec le callback onError. Une fois OnError appelé, la séquence se termine et aucun autre OnNext ne sera émis. Toujours gérer les erreurs pour éviter les exceptions non gérées qui crashent l'application."}},{"@type":"Question","name":"Qu'est-ce que l'opérateur CombineLatest et quand l'utiliser ?","acceptedAnswer":{"@type":"Answer","text":"CombineLatest combine les dernières valeurs de plusieurs séquences observables en appliquant une fonction de sélection et émet un nouveau résultat chaque fois qu'au moins une des sources change. Il attend que toutes les sources aient émis au moins une valeur avant la première émission. Utile pour combiner plusieurs états réactifs : par exemple, activer un bouton Submit uniquement si nom ET email sont valides. Différent de Zip qui émet par paires d'index correspondants, CombineLatest réémet à chaque changement de source."}},{"@type":"Question","name":"Comment fonctionne l'opérateur Zip dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"Zip combine les éléments de plusieurs séquences observables en tuples par index correspondant : le 1er élément de chaque source forme le 1er tuple, le 2ème élément de chaque source forme le 2ème tuple, etc. Un tuple n'est émis que lorsque toutes les sources ont émis à l'index correspondant. La séquence résultante se termine quand la plus courte source se termine. Utile pour synchroniser des flux temporels différents ou combiner des résultats par paires ordonnées. Différent de CombineLatest qui réémet à chaque changement."}},{"@type":"Question","name":"Qu'est-ce que l'opérateur DistinctUntilChanged et à quoi sert-il ?","acceptedAnswer":{"@type":"Answer","text":"DistinctUntilChanged filtre les éléments consécutifs dupliqués en ne transmettant un élément que s'il est différent du précédent. Par exemple, la séquence 1, 1, 2, 2, 2, 3, 1 devient 1, 2, 3, 1. Utile pour éviter les traitements redondants dans les UI réactives : si un état change de A à A, ne pas rerender. Par défaut, utilise l'égalité par défaut mais accepte un comparateur personnalisé. DistinctUntilChanged ne compare que les éléments consécutifs, différent de Distinct qui élimine tous les doublons dans toute la séquence."}},{"@type":"Question","name":"Comment utiliser l'opérateur Publish pour convertir une observable Cold en Hot ?","acceptedAnswer":{"@type":"Answer","text":"Publish transforme une observable Cold en ConnectableObservable Hot qui partage une seule souscription source entre tous les abonnés. Appeler Publish() retourne une ConnectableObservable qui ne commence à émettre que lorsque Connect() est appelé. Tous les abonnés avant et après Connect() partagent la même séquence. Utiliser RefCount() après Publish() pour connecter/déconnecter automatiquement selon le nombre d'abonnés actifs. PublishLast, PublishReplay existent aussi pour différents comportements de cache. Essentiel pour éviter des side effects multiples comme plusieurs appels HTTP."}},{"@type":"Question","name":"Qu'est-ce que le backpressure en programmation réactive et comment le gérer dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"Backpressure survient quand un producteur émet des événements plus rapidement que le consommateur ne peut les traiter, causant surcharge mémoire ou perte de données. Rx.NET n'a pas de support backpressure natif comme RxJava, mais offre des stratégies : Throttle/Sample pour ignorer des éléments, Buffer pour accumuler par lots, Window pour traiter par fenêtres temporelles, ou ObserveOn avec scheduler pour déléguer sur un thread dédié. Pour contrôle strict, utiliser un canal asynchrone avec System.Threading.Channels ou IAsyncEnumerable."}},{"@type":"Question","name":"Quelle est la différence entre ObserveOn et SubscribeOn dans Rx.NET ?","acceptedAnswer":{"@type":"Answer","text":"SubscribeOn spécifie le scheduler sur lequel la souscription initiale et la génération des éléments se produisent (affecte toute la chaîne en amont). ObserveOn spécifie le scheduler sur lequel les notifications OnNext, OnError, OnCompleted sont reçues par l'observateur (affecte uniquement en aval). Par exemple : observable.SubscribeOn(ThreadPool).ObserveOn(UIScheduler) génère les données sur un thread pool mais notifie l'UI sur le thread UI. SubscribeOn peut être placé n'importe où, ObserveOn affecte depuis son emplacement."}},{"@type":"Question","name":"Pourquoi est-il important de disposer les abonnements Rx.NET et comment le faire ?","acceptedAnswer":{"@type":"Answer","text":"Ne pas disposer les abonnements Rx cause des fuites mémoire car l'observable garde une référence vers l'observateur, empêchant le garbage collection. Subscribe() retourne un IDisposable qui doit être appelé pour annuler l'abonnement. Utiliser using pour disposer automatiquement, stocker dans CompositeDisposable pour grouper plusieurs abonnements, ou utiliser TakeUntil pour terminer automatiquement sur un événement. Dans les UI, disposer dans OnDestroy/Dispose. Les observables qui complètent naturellement se disposent automatiquement mais pas les infinies comme Interval."}}]}