Connaissez-vous ReactiveUI ?

Au cours d'un entretien, on m'a demandé : « Connaissez-vous ReactiveUI ? » . La réponse est NON . Alors mon interlocuteur m'a présenté le framework et m'a demandé de s'informer au sujet. Ce poste est sur ce que j'ai appris de cette requête.

Avant que je présente le framwork j’aimerais faire le tour sur quelque notion de base

Qu’est-ce qu’on doit connaitre ?

Programmation réactive VS programmation interactive

La programmation interactive signifie que vous êtes responsable de retirer un événement d'une file d'attente. La programmation réactive signifie que vous enregistrez un rappel et qu'un framework est chargé d'appeler correctement votre rappel.

Programmation Déclarative VS programmation Impérative

En programmation déclarative, on décrit le quoi, c'est-à-dire le problème. ... Alors qu'en programmation impérative (par exemple, avec le C ou Java), on décrit le comment, c'est-à-dire la structure de contrôle correspondant à la solution.

·    

•   La programmation déclarative est un paradigme de programmation … qui exprime la logique d'un calcul sans décrire son flux de contrôle. Avec la programmation déclarative, vous écrivez du code qui décrit ce que vous voulez, mais pas nécessairement comment l'obtenir (déclarez vos résultats souhaités, mais pas le pas à pas.
•   La programmation impérative est un paradigme de programmation qui utilise des instructions qui modifient l'état d'un programme. Avec la programmation impérative, vous dites au compilateur ce que vous voulez qu'il se passe, étape par étape.

Example C#

Avec une liste d'entrée on veux extraire la liste des entier paire:

List<int> collection = new List<int> { 1, 2, 3, 4, 5 };

En programmation Impérative :

List<int> results = new List<int>();
foreach(var num in collection)
{
if (num % 2 != 0)
results.Add(num);
}        

En programmation Déclarative

var results = collection.Where( num => num % 2 != 0);
         

Design pattern observateur (observer)

Observer est un modèle de conception comportementale. Il précise la communication entre les objets : observables et observateurs.

 Un observable est un objet qui informe les observateurs des changements de son état.

 L’Observateur permet de mettre en place un mécanisme de souscription pour envoyer des notifications à plusieurs objets, au sujet d’événements concernant les objets qu’ils observent.

Observer VS Pub/sub 

Dans le modèle Observateur, les Observateurs connaissent le Sujet, et le Sujet conserve également un enregistrement des Observateurs. Alors que, dans Publisher/Subscriber, les éditeurs et les abonnés n'ont pas besoin de se connaître. Ils communiquent simplement à l'aide de files d'attente de messages ou d'un courtier.

Logicielle Composable

La compossibilité est un principe de conception de système qui traite des interrelations des composants. Un système hautement composable fournit des composants qui peuvent être sélectionnés et assemblés dans diverses combinaisons pour répondre aux besoins spécifiques des utilisateurs.

Dans le contexte de programmation fonctionnelle - toute fonction ne dépend que de ses paramètres d'entrée, et la sortie peut être transmise à n'importe quelle fonction qui peut gérer le type de la valeur de retour.

Programmation fonctionnelle 

La programmation fonctionnelle est un paradigme de programmation de type déclaratif qui considère le calcul en tant qu'évaluation de fonctions mathématiques.

Le paradigme fonctionnel n'utilise pas de machine à états pour décrire un programme, mais un emboîtement de fonctions qui agissent comme des « boîtes noires » que l'on peut imbriquer les unes dans les autres. Chaque boîte possédant plusieurs paramètres en entrée mais une seule sortie.

Une définition très simple de la programmation fonctionnelle est la suivante : écrire un programme uniquement en fonctions pures.

Les fonctions pures

Les fonctions pures sont des fonctions qui acceptent des entrées et renvoient une valeur sans modifier aucune donnée en dehors de son scope (effets secondaires, s’appelle aussi effet de bord en anglais side-effectx). Sa valeur de sortie ou de retour doit dépendre des entrées/arguments et les fonctions pures doivent retourner une valeur.

ReactiveUI

Après que j’ai présenté tous ces termes je peux vous dire que :

ReactuveUI est Un framework réactif, composable , Declarative et fonctionnel pour toutes les plates-formes .NET !

ReactiveUI est un framework MVVM  composable et multiplateforme pour toutes les plateformes .NET qui s'inspire de la programmation réactive fonctionnelle, qu’il permet d’abstraire l'état mutable des interfaces utilisateur IHM et d'exprimer l'idée autour d'une fonctionnalité en un seul endroit lisible ce qu’il améliore la testabilité des  applications.

Avec ReactiveUI :

• La logique métier peut être composée et exprimée de manière déclarative, en utilisant les opérateurs Rx.
•  Créer et manipuler des flux. Un flux est une séquence d’événements en cours classés dans le temps. Il peut émettre trois choses différentes : une valeur d'un certain type, une erreur ou un signal « terminé ». Un flux peut être utilisé comme entrée d'un autre. Même plusieurs flux peuvent être utilisés comme entrées vers un autre flux.
•  Offrir des opérateurs permet de combiner, créer et filtrer n'importe lequel de ces flux.

Les Observables :

• ReactiveObject : ReactiveObject est l'objet de base des classes ViewModel et implémente INotifyPropertyChanged. De plus, ReactiveObject fournit des observables changeants et modifiés pour surveiller les changements d'objet.
• ReactiveCommand : ReactiveCommandest une implémentation réactive et asynchrone de l'interface ICommand. ICommand est souvent utilisé dans le modèle de conception MVVM pour permettre à la vue de déclencher la logique métier définie dans le modèle de vue.

Les Operateurs :

ci-dessous une liste des operateurs Reactivex , pour chaque operateur il y a un correspondant dans le framwork ReactiveUI.

veuillez trouver la liste de correspondance sous ce lien

Opérateur pour créer des observables : Opérateurs à l'origine de nouveaux Observables.

• Create - créer un Observable à partir de zéro en appelant des méthodes d'observation par programme
• Defer — ne créez pas l'Observable tant que l'observateur n'est pas abonné, et créez un nouvel Observable pour chaque observateur
• Empty/ Never/Throw — créer des observables qui ont un comportement très précis et limité
• From — convertir un autre objet ou structure de données en un Observable
• Interval — créer un Observable qui émet une séquence d'entiers espacés d'un intervalle de temps particulier
• Just — convertir un objet ou un ensemble d'objets en un Observable qui émet tel ou ces objets
• Range — créer un Observable qui émet une plage d'entiers séquentiels
• Repeat — créer un Observable qui émet un élément particulier ou une séquence d'éléments à plusieurs reprises
• Start — créer un Observable qui émet la valeur de retour d'une fonction
• Timer — créer un Observable qui émet un seul élément après un délai donné

Opérateur pour Transformer les observables

Opérateurs qui transforment les éléments émis par un Observable.

• Buffer — rassembler périodiquement les éléments d'un Observable en paquets et émettre ces paquets plutôt que d'émettre les éléments un à la fois
• FlatMap — transformer les éléments émis par un Observable en Observables, puis aplatir les émissions de ceux-ci en un seul Observable
• GroupBy — diviser un Observable en un ensemble d'Observables qui émettent chacun un groupe d'éléments différent de l'Observable d'origine, organisé par clé
• Map — transformer les items émis par un Observable en appliquant une fonction à chaque item
• Scan — appliquer une fonction à chaque élément émis par un Observable, séquentiellement, et émettre chaque valeur successive
• Window — subdiviser périodiquement les éléments d'un Observable en fenêtres Observable et émettre ces fenêtres plutôt que d'émettre les éléments un à la fois

Opérateur pour Filtrage des observables

Opérateurs qui émettent sélectivement des éléments à partir d'une source Observable.

• Debounce - n'émet un élément d'un Observable que si un laps de temps particulier s'est écoulé sans qu'il n'émette un autre élément
• Distinct — supprimer les éléments en double émis par un Observable
• ElementAt— émettre uniquement l'élément n émis par un Observable
• Filter — émettre uniquement les éléments d'un Observable qui réussissent un test de prédicat
• First — émettre uniquement le premier élément, ou le premier élément qui remplit une condition, à partir d'un Observable
• IgnoreElements - n'émet aucun élément d'un Observable mais reflète sa notification de fin
• Last — n'émet que le dernier élément émis par un Observable
• Sample — émettre l'élément le plus récent émis par un Observable dans des intervalles de temps périodiques
• Skip— supprimer les n premiers éléments émis par un Observable
• SkipLast— supprimer les n derniers éléments émis par un Observable
• Take— émettre uniquement les n premiers éléments émis par un Observable
• TakeLast— n'émettre que les n derniers éléments émis par un Observable

Opérateur pour Combiner des observables

Opérateurs qui travaillent avec plusieurs Observables sources pour créer un seul Observable

• And/ Then/When — combiner des ensembles d'éléments émis par deux ou plusieurs Observables au moyen dePatternet d'Planintermédiaires
• CombineLatest — lorsqu'un élément est émis par l'un des deux Observables, combiner le dernier élément émis par chaque Observable via une fonction spécifiée et émettre des éléments en fonction des résultats de cette fonction
• Join — combiner les éléments émis par deux Observables chaque fois qu'un élément d'un Observable est émis pendant une fenêtre temporelle définie en fonction d'un élément émis par l'autre Observable
• Merge — combiner plusieurs observables en un seul en fusionnant leurs émissions
• StartWith — émettre une séquence spécifiée d'éléments avant de commencer à émettre les éléments de la source Observable
• Switch — convertir un Observable qui émet des Observables en un seul Observable qui émet les éléments émis par le plus récemment émis de ces Observables
• Zip — combiner les émissions de plusieurs observables via une fonction spécifiée et émettre des éléments uniques pour chaque combinaison en fonction des résultats de cette fonction

Opérateurs de gestion des erreurs

Opérateurs qui aident à récupérer des notifications d'erreur d'un Observable

• Catch— récupérer d'une onErrornotification en continuant la séquence sans erreur
• Retry— si une source Observable envoie une onErrornotification, réabonnez-vous en espérant qu'elle se terminera sans erreur

Opérateurs de services publics observables

Une boîte à outils d'opérateurs utiles pour travailler avec des observables

• Delay — décaler les émissions d'un observable vers l'avant dans le temps d'une quantité particulière
• Do — enregistrer une action à entreprendre sur une variété d'événements de cycle de vie observables
• Materialize/Dematerialize — représenter à la fois les éléments émis et les notifications envoyées en tant qu'éléments émis, ou inverser ce processus
• ObserveOn — spécifier l'ordonnanceur sur lequel un observateur observera cet Observable
• Serialize — forcer un Observable à faire des appels sérialisés et à bien se comporter
• Subscribe — opérer sur les émissions et les notifications d'un Observable
• SubscribeOn — spécifier le programmateur qu'un Observable doit utiliser lorsqu'il est abonné à
• TimeInterval — convertir un observable qui émet des éléments en un autre qui émet des indications sur le temps écoulé entre ces émissions
• Timeout — refléter la source Observable, mais émettre une notification d'erreur si une période de temps particulière s'écoule sans aucun élément émis
• Timestamp — attacher un horodatage à chaque élément émis par un Observable
• Using — créer une ressource jetable qui a la même durée de vie que l'observable

Opérateurs conditionnels et booléens

Opérateurs qui évaluent un ou plusieurs Observables ou éléments émis par Observables

• All — déterminer si tous les éléments émis par un observable répondent à certains critères
• Amb — étant donné deux Observables sources ou plus, émettre tous les éléments à partir du premier de ces Observables seulement pour émettre un élément
• Contains — déterminer si un Observable émet ou non un élément particulier
• DefaultIfEmpty — émettre des éléments de l'Observable source, ou un élément par défaut si l'Observable source n'émet rien
• SequenceEqual — déterminer si deux observables émettent la même séquence d'éléments
• SkipUntil — défaussez les éléments émis par un Observable jusqu'à ce qu'un deuxième Observable émette un élément
• SkipWhile — rejeter les éléments émis par un Observable jusqu'à ce qu'une condition spécifiée devienne fausse
• TakeUntil — rejeter les éléments émis par un Observable après qu'un deuxième Observable ait émis un élément ou se termine
• TakeWhile — rejeter les éléments émis par un Observable après qu'une condition spécifiée soit devenue fausse

Opérateurs mathématiques et agrégés

Opérateurs qui opèrent sur toute la séquence d'éléments émis par un Observable

• Average — calcule la moyenne des nombres émis par un Observable et émet cette moyenne
• Concat — émettre les émissions de deux ou plusieurs Observables sans les entrelacer
• Count — compter le nombre d'items émis par la source Observable et n'émettre que cette valeur
• Max — déterminer et émettre l'élément de valeur maximale émis par un Observable
• Min — déterminer et émettre l'élément de valeur minimale émis par un Observable
• Reduce — appliquer une fonction à chaque élément émis par un Observable, séquentiellement, et émettre la valeur finale
• Sum — calculer la somme des nombres émis par un Observable et émettre cette somme

Opérateurs de contre-pression

• Opérateurs de contre-pression - stratégies pour faire face aux Observables qui produisent des éléments plus rapidement que leurs observateurs ne les consomment

Opérateurs observables connectables

Observables de spécialité qui ont une dynamique d'abonnement plus précisément contrôlée

• Connect — demander à un observable connectable de commencer à émettre des éléments à ses abonnés
• Publish — convertir un Observable ordinaire en un Observable connectable
• RefCount — faire en sorte qu'un observable connectable se comporte comme un observable ordinaire
• Replay — s'assurer que tous les observateurs voient la même séquence d'éléments émis, même s'ils s'abonnent après que l'observable a commencé à émettre des éléments

Opérateurs pour convertir les observables

• To — convertir un Observable en un autre objet ou structure de données

Bon, c'est tout pour l'instant. J'espère que vous avez l'idée. Merci d'avoir lu l'article. S'il vous plaît laissez-moi savoir s'il y a une erreur ou une modification nécessaire. Merci d'avance.

Je trouve que ce vidéo utile pour comprendre les notions de base de ReactiveUI