Extensions réactives

Les extensions réactives (Rx) sont une bibliothèque permettant de composer des programmes asynchrones et basés sur des événements à l’aide de séquences observables et d’opérateurs de requête de style LINQ.

Les séquences de données peuvent prendre de nombreuses formes, comme un flux de données à partir d’un fichier ou d’un service web, des demandes de services web, des notifications système ou une série d’événements tels que l’entrée utilisateur.

Les extensions réactives représentent toutes ces séquences de données en tant que séquences observables. Une application peut s’abonner à ces séquences observables pour recevoir des notifications asynchrones à mesure que de nouvelles données arrivent. La bibliothèque Rx est disponible pour le développement d’applications de bureau dans .NET. Il est également publié pour Silverlight, Windows Phone 7 et JavaScript. Pour plus d’informations sur ces différentes plateformes, consultez la rubrique Différences entre les versions de Rx .

Extraction et envoi de données

Dans la programmation interactive, l’application interroge activement une source de données pour obtenir plus d’informations en extrayant les données d’une séquence qui représente la source. Ce comportement est représenté par le modèle d’itérateur de IEnumerable<T>/IEnumerator<T>. L’interface IEnumerable<T> expose une méthode unique GetEnumerator() qui retourne un IEnumerator<T> pour itérer au sein de cette collection.  L’IEnumerator<T> nous permet d’obtenir l’élément actuel (en retournant la propriété Current) et de déterminer s’il y a d’autres éléments à itérer (en appelant la méthode MoveNext). 

L’application est active dans le processus de récupération des données : en plus d’obtenir un énumérateur en appelant GetEnumerator, elle contrôle également le rythme de la récupération en appelant MoveNext à sa convenance. Ce modèle d’énumération est synchrone, ce qui signifie que l’application peut être bloquée lors de l’interrogation de la source de données. Ce modèle de tirage est similaire à la visite de votre bibliothèque et à la consultation d’un livre. Une fois que vous avez terminé avec le livre, vous payez une autre visite pour case activée un autre.

En revanche, dans la programmation réactive, l’application reçoit plus d’informations en s’abonnant à un flux de données (appelé séquence observable dans Rx), et toute mise à jour lui est transmise à partir de la source. L’application est passive dans le processus de récupération des données : en plus de s’abonner à la source observable, elle n’interroge pas activement la source, mais elle réagit simplement aux données qui lui sont envoyées. Lorsque le flux n’a plus de données à offrir, ou lorsqu’il se trompe, la source envoie une notification à l’abonné. De cette façon, l’application ne sera pas bloquée en attendant la mise à jour de la source.

Il s’agit du modèle d’envoi (push) utilisé par les extensions réactives. C’est similaire à rejoindre un club de lecture dans lequel vous inscrivez votre intérêt pour un genre particulier, et les livres qui correspondent à votre intérêt vous sont automatiquement envoyés au fur et à mesure qu’ils sont publiés. Vous n’avez pas besoin de vous tenir en ligne pour acquérir quelque chose que vous voulez. L’utilisation d’un modèle push est utile dans de nombreux scénarios, en particulier dans un environnement lourd en interface utilisateur dans lequel le thread d’interface utilisateur ne peut pas être bloqué pendant que l’application attend certains événements. Cela est également essentiel dans les environnements de programmation tels que Silverlight, qui a son propre ensemble d’exigences asynchrones. En résumé, en utilisant Rx, vous pouvez rendre votre application plus réactive.

Le modèle push implémenté par Rx est représenté par le modèle observable de IObservable<T>/IObserver<T>. L’interface IObservable<T> est un double de l’interface IEnumerable<T> familière. Il extrait une séquence de données et conserve une liste des implémentations T> IObserver<qui s’intéressent à la séquence de données. IObservable informe automatiquement tous les observateurs de tout changement d’état. Pour inscrire un intérêt via un abonnement, vous utilisez la méthode Subscribe de IObservable, qui prend un IObserver et retourne un IDisposable. Cela vous donne la possibilité de suivre et de supprimer l’abonnement. En outre, l’implémentation LINQ de Rx sur des séquences observables permet aux développeurs de composer des requêtes de traitement d’événements complexes sur des séquences push telles que les événements .NET, les calculs basés sur APM (« IAsyncResult »), les calculs<basés sur les tâches T>, les API de capteur et d’emplacement Windows 7, les flux d’événements temporels SQL StreamInsight, les événements de première classe F# et les flux de travail asynchrones. Pour plus d’informations sur les interfaces T>/IObserver<<T>, consultez Exploration des interfaces principales dans Rx. Pour obtenir des tutoriels sur l’utilisation des différentes fonctionnalités de Rx, consultez Utilisation de Rx.