Qu'est-ce que les observables chauds et froids ?

Question

J'ai regardé la vidéo et je connais les principes généraux - le chaud se produit même si personne n'est abonné, le froid se produit "à la demande". En outre, Publish() convertit le froid en chaud et Defer() convertit le chaud en froid.

Mais j'ai toujours l'impression de passer à côté de certains détails. Voici quelques questions auxquelles j'aimerais que l'on réponde :

• Pouvez-vous donner une définition complète de ces termes ?
• Est-il parfois utile d'appeler Publish sur un observable chaud ou Defer sur un observable froid ?
• Quels sont les aspects des conversions chaudes/froides - perdez-vous des messages, par exemple ?
• Existe-t-il des différences entre les définitions à chaud et à froid pour IObservable et IEnumerable ?
• Quels sont les principes généraux à prendre en compte lors de la programmation du froid ou du chaud ?
• D'autres conseils sur les observables chauds/froids ?

Answer 1

De : Livre d'Anton Moiseev "Angular Development with Typescript, deuxième édition". :

Observables chauds et froids

Il y a dos types de observables : chaud et froid. Les principaux différence est qu'un froid observable crée a données producteur para chaque abonné , alors qu'un observable à chaud crée a producteur de données d'abord y chaque abonné obtient le données de un producteur , démarrage de le moment de abonnement .

Comparons l'observation d'un film en Netflix d'entrer dans une cinéma . Considérez-vous comme un observateur . Toute personne qui décide de regarder Mission : Impossible sur Netflix aura droit à l'intégralité du l'intégralité du film, quel que soit le moment où il appuie sur le bouton de lecture. Netflix crée un nouveau producteur pour visionner un film juste pour vous. Il s'agit d'un froid observable .

Si vous allez au cinéma et que l'heure de la séance est 16 heures, le producteur est créé à 16 heures. est créé à 16 heures et la diffusion en continu commence. Si certaines personnes ( abonnés ) sont en retard au spectacle, ils manquent le début du et ne peuvent le regarder qu'à partir du moment où ils sont arrivés. Cette est un observable à chaud .

A froid observable commence à produire des données lorsqu'un code invoque un subscribe() sur elle. Par exemple, votre application peut déclarer un observable fournissant une URL sur le serveur pour obtenir certains produits. La ne sera effectuée que si vous vous y abonnez. Si un autre script fait la même demande au serveur, il obtiendra le même ensemble de données.

A observable à chaud produit des données même si aucun abonné n'est n'est intéressé par ces données. Par exemple, l'accéléromètre de votre smartphone produit des données sur la position de votre appareil, même si aucune ne s'abonne à ces données. Un serveur peut produire les derniers cours de même si aucun utilisateur n'est intéressé par cette action.

Answer 2

Les observables chauds sont ceux qui poussent des événements alors que vous n'êtes pas abonné à l'observable. Comme les mouvements de la souris, ou les tics de la minuterie, ou tout autre chose de ce genre. Les observables froids sont ceux qui commencent à pousser uniquement lorsque vous vous abonnez, et qui recommencent si vous vous abonnez à nouveau.

Answer 3

J'espère que cela vous aidera.

Pouvez-vous nous donner un aperçu complet de la situation ? une définition complète de ces termes ?

Voir mon article de blog à l'adresse suivante https://leecampbell.com/2010/08/19/rx-part-7-hot-and-cold-observables

Est-il parfois utile d'appeler Publish sur un observable chaud ou Defer sur un observable froid ?

Non, pas que je sache.

Quels sont les aspects du chaud/froid ? les conversions - perdez-vous des messages, par exemple ?

Il est possible de "perdre" des messages lorsque l'observable est chaud, car les "événements" se produisent indépendamment des abonnés.

Existe-t-il des différences entre la chaleur et l'humidité ? les définitions à chaud et à froid pour IObservable et IEnumerable ?

Je ne comprends pas vraiment la question. J'espère que cette analogie vous aidera. Je comparerais un Observable chaud à un IEnumerable évalué avec empressement, c'est-à-dire qu'une liste ou un tableau sont tous deux évalués avec empressement et ont été remplis même si personne ne les énumère. Une instruction yield qui récupère des valeurs d'un fichier ou d'une base de données peut être évaluée paresseusement à l'aide du mot-clé Yield. Bien que la paresse puisse être une bonne chose, elle sera par défaut réévaluée si un second énumérateur s'y intéresse. Si l'on compare ces éléments aux observables, un observable chaud peut être un événement (clic sur un bouton) ou un flux de températures ; ces événements se produiront indépendamment d'un abonnement et seront également partagés si plusieurs abonnements sont effectués pour le même observable. Observable.Interval est un bon exemple d'observable froid. Il ne commencera à produire des valeurs que lorsqu'un abonnement sera effectué. Si plusieurs abonnements sont effectués, la séquence sera réévaluée et les "événements" se produiront à des moments différents (en fonction du temps écoulé entre les abonnements).

Quels sont les principes généraux à prendre en compte lors de la programmation du froid ou du chaud ?

Voir le lien au point 1. Je vous recommande également d'étudier la possibilité d'utiliser Publsh en conjonction avec RefCount. Cela vous permet d'avoir la sémantique d'évaluation paresseuse des observables froids, mais le partage des événements que les observables chauds obtiennent.

D'autres conseils sur les observables observables ?

Salissez-vous les mains et jouez avec eux. Une fois que vous avez lu à leur sujet pendant plus de 30 minutes, le temps passé à coder avec eux est bien plus productif pour vous que de lire davantage :)

Answer 4

Sans prétendre donner une réponse exhaustive, je voudrais résumer de la manière la plus simple ce que j'ai appris depuis l'époque de cette question.

Observable à chaud correspond exactement à l'événement. Dans les événements, les valeurs sont généralement introduites dans le gestionnaire même si aucun abonné n'écoute. Tous les abonnés reçoivent le même ensemble de valeurs. Parce qu'ils suivent le modèle "event", les observables chauds sont plus facile à comprendre que les froids.

Observable à froid est également semblable à un événement, mais avec une particularité : l'événement de l'observable Cold n'est pas une propriété d'une instance partagée, c'est une propriété d'un objet qui est produit par une usine chaque fois que quelqu'un s'y abonne. En outre, l'abonnement déclenche la production des valeurs. En raison de ce qui précède, plusieurs abonnés sont isolés et chacun reçoit son propre ensemble de valeurs.

L'erreur la plus courante commise par les débutants RX est de créer un observable froid (enfin, de penser qu'ils créent un observable froid) en utilisant certaines variables d'état au sein d'une fonction (par exemple, le total accumulé) et de ne pas l'envelopper dans une instruction .Defer(). En conséquence, plusieurs abonnés partagent ces variables et provoquent des effets de bord entre eux.