WEBVTT

00:00:00.000 --> 00:00:03.190
D'accord. Bonjour.
Comment va tout le monde ?

00:00:03.380 --> 00:00:08.280
Quatrième à la voie à travers
notre Sommet Xam ici.

00:00:08.280 --> 00:00:12.870
Alors oui, je suis Shane
Neuville. Il a bien orthographié?

00:00:12.870 --> 00:00:17.715
ouais. Shane Neuville. Je suis
avec l'équipe Xamarin Forms.

00:00:17.715 --> 00:00:20.280
Avant d'être avec Xamarin Forms,

00:00:20.280 --> 00:00:23.490
J'ai travaillé un montant décent
avec le ReactiveUI.

00:00:23.490 --> 00:00:26.160
Donc j'essaie toujours de défendre
que autant que je

00:00:26.160 --> 00:00:29.310
peut même de l'intérieur de Microsoft.

00:00:29.310 --> 00:00:35.970
Donc, le discours ici va être
fortement sur les extensions réactives,

00:00:35.970 --> 00:00:39.990
spécifiquement juste les concepts
derrière le lecteur réactif,

00:00:39.990 --> 00:00:42.990
comment ils sont proches des événements.

00:00:42.990 --> 00:00:44.975
Puis plus tard, Michael va faire

00:00:44.975 --> 00:00:47.600
une conférence plus approfondie sur
cartographier plus comme

00:00:47.600 --> 00:00:52.040
MVVM et comment alimenter
vos cadres pour cela.

00:00:52.040 --> 00:00:56.055
Donc, pour nous faire commencer avec cela,

00:00:56.055 --> 00:00:59.305
combien de personnes ont utilisé
Extensions réactives,

00:00:59.305 --> 00:01:01.350
juste pour obtenir, "Oh, hey. C'est gentil."?

00:01:01.350 --> 00:01:02.895
Chaque fois que je demandais,
il y a plus de mains.

00:01:02.895 --> 00:01:08.040
C'est bon signe. Voyons.

00:01:08.040 --> 00:01:12.250
Combien de personnes pensent que je parle
à propos de JavaScript et ReactJS?

00:01:12.250 --> 00:01:15.250
Ce type là-bas, lui ? D'accord.

00:01:16.130 --> 00:01:20.150
Donc, certains des vernaculaires
commencé à éclaircir ainsi.

00:01:20.150 --> 00:01:23.450
Est-ce que quelqu'un pense que je vais
parler de collections observables

00:01:23.450 --> 00:01:26.940
pendant environ une heure? Lol D'accord.

00:01:26.940 --> 00:01:29.990
Donc, le long de cela, ce cadre

00:01:29.990 --> 00:01:33.530
devient un peu moins
pertinentes au fur et à mesure que les pourparlers se pourontient.

00:01:33.530 --> 00:01:37.580
Il y avait certainement
une certaine confusion qui a commencé.

00:01:37.580 --> 00:01:39.980
Donc, je me souviens de la première
fois que j'ai entendu parler de ReactJS.

00:01:39.980 --> 00:01:42.955
Je faisais du RxJS depuis un certain temps.

00:01:42.955 --> 00:01:45.380
C'était environ cinq minutes
dans la conversation,

00:01:45.380 --> 00:01:48.695
J'ai réalisé que nous n'avions pas
la même conversation.

00:01:48.695 --> 00:01:51.890
Donc il n'y a pas vraiment

00:01:51.890 --> 00:01:55.920
toute relation il ya plus
les cinq premières lettres.

00:01:57.410 --> 00:02:01.105
L'angulaire a commencé
fortement à l'aide de RxJS.

00:02:01.105 --> 00:02:03.260
Donc, Angulaire est probablement
plus synonyme

00:02:03.260 --> 00:02:05.870
avec RxJS à ce stade, mais oui.

00:02:05.870 --> 00:02:08.810
Ensuite, la zone suivante
où les gens se jettent

00:02:08.810 --> 00:02:12.305
off a à voir avec le
RéactifX et ReactiveUI,

00:02:12.305 --> 00:02:14.345
et où se trouvent ces points de division.

00:02:14.345 --> 00:02:21.810
ReactiveX est donc
un concept de plate-forme-agnostique.

00:02:21.810 --> 00:02:25.760
Donc, le concept ReactiveX

00:02:25.760 --> 00:02:28.940
est mis en œuvre à travers
cadres multiples.

00:02:28.940 --> 00:02:35.390
Il y a donc un coco, un Java, un RxJS.

00:02:35.390 --> 00:02:40.515
Il y a toute une série de langues
qui mettent en œuvre les concepts.

00:02:40.515 --> 00:02:45.090
Ensuite, ReactiveUI est la couche MVVM

00:02:45.090 --> 00:02:48.750
qui aide à brancher ReactiveX
dans votre MVVM.

00:02:48.750 --> 00:02:52.905
Donc, quand les gens sont
parler de Réactif,

00:02:52.905 --> 00:02:54.705
ils ne sont pas seulement parler
sur ReactiveUI.

00:02:54.705 --> 00:02:55.820
Ils parlent principalement de

00:02:55.820 --> 00:02:59.090
programmation réactive fonctionnelle et

00:02:59.090 --> 00:03:02.810
comment observable basé
paradigmes de programmation de travail.

00:03:02.810 --> 00:03:05.870
Donc, l'aspect RéactifX est

00:03:05.870 --> 00:03:10.655
en grande partie ce que ce discours est
va tourner autour,

00:03:10.655 --> 00:03:15.245
qui sera un bon précurseur
pour le discours de Michael plus tard.

00:03:15.245 --> 00:03:18.830
Alors pourquoi m'a-t-il bip ?

00:03:18.830 --> 00:03:20.240
Attendez. J'ai probablement
peut-être que je ne l'ai pas

00:03:20.240 --> 00:03:22.845
Souligné. Et voilà.

00:03:22.845 --> 00:03:29.300
Donc, nous allons décomposer ce que
nous regardons vraiment ici.

00:03:29.300 --> 00:03:32.420
Parlons donc de
événements très rapides.

00:03:32.420 --> 00:03:35.570
Alors, comment vous abonnez-vous à
Événements? C'est assez basique.

00:03:35.570 --> 00:03:37.945
On a tous déjà vu ce code.

00:03:37.945 --> 00:03:41.190
Et voilà. C'est excitant, non ?

00:03:41.190 --> 00:03:46.085
Si efficacement, vous avez
votre éditeur à gauche.

00:03:46.085 --> 00:03:48.260
Vous avez vos événements
et puis vous avez

00:03:48.260 --> 00:03:50.990
votre observateur sur la droite là-bas.

00:03:50.990 --> 00:03:57.230
Donc, c'est un événement de base
modèle de notification,

00:03:57.230 --> 00:03:58.760
votre modèle d'observateur de base.

00:03:58.760 --> 00:04:02.030
Donc, c'était la syntaxe dans le cm 1.

00:04:02.030 --> 00:04:04.190
En effet, le haut
on fait la même chose

00:04:04.190 --> 00:04:06.395
comme le fond, mais le sucre syntaxique.

00:04:06.395 --> 00:04:10.725
Donc, nous allons briser ce qu'est un événement.

00:04:10.725 --> 00:04:14.005
Donc, un événement est essentiellement,

00:04:14.005 --> 00:04:21.095
c'est une série de choses individuelles
qui se produisent aux données de production.

00:04:21.095 --> 00:04:25.260
Donc si je tape mon nom,

00:04:25.990 --> 00:04:29.930
Je tape S, il y a
un événement, h et un événement,

00:04:29.930 --> 00:04:33.635
a et l'événement, je pense que vous voyez
où tout ça va,

00:04:33.635 --> 00:04:39.080
et la représentation
de ces données est ici.

00:04:39.080 --> 00:04:41.990
Voilà donc l'ensemble des données qui ont

00:04:41.990 --> 00:04:46.325
s'est produite en fonction de ces événements.

00:04:46.325 --> 00:04:49.220
C'est donc votre événement.

00:04:49.220 --> 00:04:51.455
Donc rien de trop hallucinant
à ce stade.

00:04:51.455 --> 00:04:55.340
Donc, les étapes pour arrêter d'observer un événement.

00:04:55.340 --> 00:04:58.000
Alors, comment pouvez-vous arrêter
l'observation d'un événement?

00:04:58.000 --> 00:05:00.600
Nous n'avons pas tous été observés
événements front, non?

00:05:00.600 --> 00:05:01.760
Comme nous l'avons tous dit, "Hé, je ne

00:05:01.760 --> 00:05:03.620
plus se soucier de ce que
cette chose arrive.

00:05:03.620 --> 00:05:08.960
Donc, habituellement, le processus
de comprendre comment

00:05:08.960 --> 00:05:11.720
pour désabonner l'événement commence

00:05:11.720 --> 00:05:15.155
avec le client se plaindre
que votre application est lente.

00:05:15.155 --> 00:05:19.070
Ainsi, les fichiers clients
un problème et dit: «Hé,

00:05:19.070 --> 00:05:21.840
mon application ralentit après l'avoir utilisé.

00:05:22.670 --> 00:05:24.690
Qu'est-ce qui ne va pas ?

00:05:24.690 --> 00:05:27.075
Plus je l'utilise,
ça ne marche pas.

00:05:27.075 --> 00:05:30.550
Donc d'abord, vous ne les croyez pas.

00:05:31.400 --> 00:05:35.090
Vous pensez qu'ils ont
installé quelque chose comme

00:05:35.090 --> 00:05:37.730
Économiseur d'écran Dilbert qui prend

00:05:37.730 --> 00:05:39.980
jusqu'à la fenêtre du navigateur entier
ou quelque chose comme ça.

00:05:39.980 --> 00:05:42.290
Parce que quand vous commencez
votre application et

00:05:42.290 --> 00:05:44.795
vous l'utilisez pour
environ 15 secondes, c'est rapide.

00:05:44.795 --> 00:05:46.895
Tout fonctionne très bien.
C'est réactif.

00:05:46.895 --> 00:05:51.670
Tu as compris que c'était parfait.

00:05:51.670 --> 00:05:54.435
Alors, vous êtes comme, "Tous les
Oui. Je suppose que je les crois.

00:05:54.435 --> 00:05:58.530
Donc, à ce stade, vous la poussière
de votre chapeau de débogage,

00:05:58.530 --> 00:06:01.110
relire à travers l'ensemble de
tests et blogs sur la façon dont

00:06:01.110 --> 00:06:04.185
pour analyser les cadres de pile,

00:06:04.185 --> 00:06:06.675
et vous commencez à tirer tout dans.

00:06:06.675 --> 00:06:08.145
Vous obtenez la pile DOMs.

00:06:08.145 --> 00:06:10.925
Vous regardez combien de temps
les objets sont vivants.

00:06:10.925 --> 00:06:13.055
Tu le fais encore et encore.

00:06:13.055 --> 00:06:15.740
Enfin, tu descends.

00:06:15.740 --> 00:06:18.290
Il y a beaucoup de regard fixe
flèches pointant vers des choses,

00:06:18.290 --> 00:06:19.940
et se demandant ce que les objets comptent,

00:06:19.940 --> 00:06:22.280
et soustraire cette
de cela jusqu'à ce que vous

00:06:22.280 --> 00:06:23.900
enfin voir qu'il ya

00:06:23.900 --> 00:06:25.595
était-ce une ligne de code ou
tu as oublié d'écrire ça.

00:06:25.595 --> 00:06:27.990
Tu es genre, "Oh, mec."
Puis, tout d'un coup,

00:06:27.990 --> 00:06:30.195
tout commence à courir super vite.

00:06:30.195 --> 00:06:33.699
Donc oui, je veux dire, en gros,

00:06:35.210 --> 00:06:38.280
s'abonner et se désabonner d'eux.

00:06:38.280 --> 00:06:43.980
C'est la sémantique.

00:06:43.980 --> 00:06:48.345
Mais la sémantique, c'est
un peu noueux, je me sens comme.

00:06:48.345 --> 00:06:52.655
Parce que l'un, vous devez
n'oubliez pas de faire deux choses.

00:06:52.655 --> 00:06:55.130
Chaque fois que je dois me souvenir
de faire plus d'une chose,

00:06:55.130 --> 00:06:57.850
vous allez échouer
habituellement dans la programmation.

00:06:57.850 --> 00:07:00.695
De plus, vous devez conserver
vos références à tout.

00:07:00.695 --> 00:07:04.040
Donc, afin de faire l'importance
de ce deuxième,

00:07:04.040 --> 00:07:05.210
vous avez besoin de tout ce qui est en

00:07:05.210 --> 00:07:08.125
votre premier à faire
tout dans votre deuxième,

00:07:08.125 --> 00:07:11.930
comme vous devez
maintenir ces idées.

00:07:11.930 --> 00:07:16.725
Donc, dans la gestion des événements en général
c'est juste, c'est salissant.

00:07:16.725 --> 00:07:20.015
Ce n'est pas le type le plus propre
d'exploitation.

00:07:20.015 --> 00:07:21.290
Je veux dire, comme disons,

00:07:21.290 --> 00:07:26.600
vous ne vous souciez que
un seul événement, par exemple,

00:07:26.600 --> 00:07:28.465
comme si nous avions tous écrit ce code,

00:07:28.465 --> 00:07:31.340
où si vous voulez
se désabonner de quelque chose comme

00:07:31.340 --> 00:07:35.600
vous ne vouliez en tirer qu'un.

00:07:35.600 --> 00:07:38.915
Donc, disons, comme une page apparaissant
ou quelque chose de cette nature

00:07:38.915 --> 00:07:42.140
donc vous devez avoir
la référence au sommet

00:07:42.140 --> 00:07:45.830
de sorte que la fermeture
l'intérieur y a accès,

00:07:45.830 --> 00:07:47.975
alors vous assignez le gestionnaire,

00:07:47.975 --> 00:07:50.255
et puis vous ne
le gestionnaire à la fin.

00:07:50.255 --> 00:07:55.280
Il y a donc cette cérémonie successive

00:07:55.280 --> 00:07:59.150
qui vient de la
ensemble d'opérations.

00:07:59.150 --> 00:08:03.050
Donc ça me semble familier. Est
tout le monde a écrit ce code avant?

00:08:03.050 --> 00:08:05.790
ouais? D'accord.

00:08:06.930 --> 00:08:12.655
Donc, et me voici encore
parler d'événements.

00:08:12.655 --> 00:08:14.860
C'est ce que j'appelle mon
Infopublicité IObservable.

00:08:14.860 --> 00:08:16.360
Où vous faites quelque chose
fou et vous êtes comme,

00:08:16.360 --> 00:08:17.680
"Oh mon Dieu, c'est si terrible."

00:08:17.680 --> 00:08:22.135
Ce n'est pas si grave. Mais ici,
J'indique tout.

00:08:22.135 --> 00:08:24.115
Ce n'est pas Xamarin Forms,

00:08:24.115 --> 00:08:26.725
lorsque vous êtes câblage jusqu'à un événement.

00:08:26.725 --> 00:08:29.485
Donc, vous fil jusqu'à l'événement,

00:08:29.485 --> 00:08:32.425
vous devez trouver d'accord,
où sont mes aspects de disposer?

00:08:32.425 --> 00:08:33.835
Ok, c'est ici.

00:08:33.835 --> 00:08:37.330
Je dois m'assurer de
se débarrasser des événements et

00:08:37.330 --> 00:08:41.350
toutes ces choses est en disparates
emplacements dans l'ensemble de votre fichier.

00:08:41.350 --> 00:08:42.730
Ce sont toutes ces choses.

00:08:42.730 --> 00:08:44.290
Cette cérémonie que vous avez à faire

00:08:44.290 --> 00:08:46.240
avec tous ces événements
systèmes de gestion.

00:08:46.240 --> 00:08:48.790
Regarde là-haut, toi.
doivent s'y abonner.

00:08:48.790 --> 00:08:51.385
Ensuite, vous avez votre gestionnaire ici.

00:08:51.385 --> 00:08:52.810
Vous traitez avec les données dans

00:08:52.810 --> 00:08:55.180
un endroit séparé et
puis se penche ici.

00:08:55.180 --> 00:08:59.635
C'est très
expérience déconnectée.

00:08:59.635 --> 00:09:01.240
Donc ici, j'ai même tapé
les mauvaises choses,

00:09:01.240 --> 00:09:03.625
Je suis tellement énervé à quel point c'est dur.

00:09:03.625 --> 00:09:07.720
Mais oui. J'ai donc eu l'infopublicité,
Où est passé le soda ?

00:09:07.720 --> 00:09:13.225
Donc, c'est le truc.

00:09:13.225 --> 00:09:18.175
Les événements sont donc ces événements singuliers
points de données synchrones.

00:09:18.175 --> 00:09:20.650
Donc, vous obtenez un changement de texte événements

00:09:20.650 --> 00:09:22.690
et puis tout ce que vous avez est
cet événement de changement de texte.

00:09:22.690 --> 00:09:24.460
Tu as juste cette lettre.
Vous avez juste cette lettre

00:09:24.460 --> 00:09:27.195
S que vous avez à traiter.

00:09:27.195 --> 00:09:29.145
Mais que faire si vous voulez
pour faire plus avec cela?

00:09:29.145 --> 00:09:31.200
Et si, parce que chaque fois
vous avez un événement,

00:09:31.200 --> 00:09:33.840
vous vous souciez très rarement
sur le seul événement.

00:09:33.840 --> 00:09:36.680
Vous vous souciez des données
ensemble d'événements.

00:09:36.680 --> 00:09:37.870
Tu te soucies de tout ce qui est

00:09:37.870 --> 00:09:40.510
se produit au fil du temps.

00:09:40.510 --> 00:09:43.750
Et si tu veux faire
quelque chose de très excitant.

00:09:43.750 --> 00:09:45.220
Et si tu veux dire,

00:09:45.220 --> 00:09:47.590
sauter vos cinq premiers événements et

00:09:47.590 --> 00:09:50.050
alors ne se soucient que des quatre prochaines,

00:09:50.050 --> 00:09:52.015
alors vous voulez défaire les événements,

00:09:52.015 --> 00:09:56.139
donc s'ils tapent super-rapide
n'attendez que deux secondes,

00:09:56.139 --> 00:09:57.610
alors disons que vous voulez filtrer

00:09:57.610 --> 00:09:59.215
tous les événements qui sont bleu fleur de maïs

00:09:59.215 --> 00:10:02.545
juste parce que c'est une couleur horrible
peut-être, je ne sais pas.

00:10:02.545 --> 00:10:05.110
Ensuite, vous voulez

00:10:05.110 --> 00:10:07.120
coup d'envoi de la demande web
et puis ils recommencent,

00:10:07.120 --> 00:10:08.860
donc tu veux juste jeter ça.

00:10:08.860 --> 00:10:12.220
Comme ce type de modèle est

00:10:12.220 --> 00:10:16.900
très fréquent dans la mesure où
votre gestion d'événements,

00:10:16.900 --> 00:10:22.630
en particulier dans les cadres MVVM et
choses qui sont plus basées sur l'interface uI.

00:10:22.630 --> 00:10:25.420
Tu dois toujours réagir.

00:10:25.420 --> 00:10:29.830
contre les points de données entrants
la connectivité se perd.

00:10:29.830 --> 00:10:31.240
Donc, comme si si
votre connectivité obtient

00:10:31.240 --> 00:10:33.460
perdu aux demandes web de pointer?

00:10:33.460 --> 00:10:34.870
Comment interrompez-vous

00:10:34.870 --> 00:10:39.745
cette demande web une fois
la connectivité est perdue?

00:10:39.745 --> 00:10:48.460
Comment faites-vous cela d'une manière fiable
qui est facile à gérer.

00:10:48.460 --> 00:10:50.680
Donc, tous ces concepts ont

00:10:50.680 --> 00:10:58.060
versions très claires des verbes
qui les cartographiait dans le réactif.

00:10:58.060 --> 00:10:59.830
Donc, ce sont tous les
choses réelles que vous pouvez

00:10:59.830 --> 00:11:02.590
utiliser en réactive pour articuler

00:11:02.590 --> 00:11:07.795
toutes ces tentatives sur vos données,

00:11:07.795 --> 00:11:09.880
flux d'événements sur l'année.

00:11:09.880 --> 00:11:13.720
D'accord. Alors quoi d'autre
pouvons-nous faire avec des événements?

00:11:13.720 --> 00:11:19.010
Pas tant que ça.
Les modèles de base très simples.

00:11:19.260 --> 00:11:23.725
C'est donc ma déchirure des événements.

00:11:23.725 --> 00:11:26.110
Donc, à ce stade, si
vous n'avez pas vraiment utilisé

00:11:26.110 --> 00:11:28.450
réactif, vous êtes probablement comme,
"Oh, j'ai été si terrible.

00:11:28.450 --> 00:11:31.600
J'ai fait ça mal, le
tout le temps », et vous avez

00:11:31.600 --> 00:11:33.610
une crise existentielle sur

00:11:33.610 --> 00:11:37.970
toutes les questions que vous n'avez pas
sais que tu l'as maintenant.

00:11:39.900 --> 00:11:45.580
Donc, nous allons traduire cette
plus à Observables.

00:11:45.580 --> 00:11:48.370
Donc, IObservable a été
autour pendant un certain temps.

00:11:48.370 --> 00:11:49.660
C'est essentiellement comme

00:11:49.660 --> 00:11:52.855
un modèle d'abonnement de publication

00:11:52.855 --> 00:11:55.900
c'est à l'intérieur du noyau
cadre of.Net et

00:11:55.900 --> 00:11:59.005
alors ReactiveX est plus de

00:11:59.005 --> 00:12:04.465
une expression de la façon d'interagir
avec ceux Observables.

00:12:04.465 --> 00:12:11.245
Donc, nous allons décomposer ce que
un Observable est ici.

00:12:11.245 --> 00:12:15.020
Donc, c'est essentiellement
un modèle d'observateur.

00:12:18.690 --> 00:12:21.790
Fondamentalement, c'est
la même chose qu'un événement.

00:12:21.790 --> 00:12:26.000
Un événement est effectivement
un modèle d'observateur.

00:12:27.420 --> 00:12:30.775
Donc, vous avez votre événement ici,

00:12:30.775 --> 00:12:34.449
votre gestionnaire et votre éditeur

00:12:34.449 --> 00:12:37.870
et puis c'est analogue
à ce droit ici.

00:12:37.870 --> 00:12:42.865
Donc, vous avez votre observable
qui regarde,

00:12:42.865 --> 00:12:45.070
son faire la même chose.

00:12:45.070 --> 00:12:47.980
Donc vous avez la même idée.

00:12:47.980 --> 00:12:51.220
Efficacement, vous pouvez faire exactement
la même chose avec les deux à ceux à

00:12:51.220 --> 00:12:54.925
la couche de base et
obtenir vos points de données.

00:12:54.925 --> 00:12:56.650
Mais ce qui est excitant maintenant,

00:12:56.650 --> 00:12:58.285
donc c'est là que les points passionnants

00:12:58.285 --> 00:13:00.620
de tout entre en jeu.

00:13:03.690 --> 00:13:07.540
Avec un événement, vous n'avez pas
vraiment quelque chose.

00:13:07.540 --> 00:13:09.385
Vous avez juste un événement.

00:13:09.385 --> 00:13:11.770
Mais maintenant, avec un observable,

00:13:11.770 --> 00:13:13.510
vous avez une représentation
de cet événement.

00:13:13.510 --> 00:13:17.095
Vous avez en fait comme un objet de données
que vous pouvez faire des choses avec.

00:13:17.095 --> 00:13:22.645
Donc, c'est la différence
entre avoir un élément de

00:13:22.645 --> 00:13:25.360
une liste au lieu d'autre chose que

00:13:25.360 --> 00:13:28.675
ayant dit toute la liste
que vous pouvez maintenant opérer plus.

00:13:28.675 --> 00:13:32.140
C'est donc là que votre
différences entrent en jeu.

00:13:32.140 --> 00:13:35.590
Ainsi, vous pouvez penser à la
observable beaucoup

00:13:35.590 --> 00:13:39.550
comme le modèle d'itérateur.

00:13:39.550 --> 00:13:42.340
Donc, ceci est tiré de réactivex. Io

00:13:42.340 --> 00:13:44.485
qui est l'une des principales sources,

00:13:44.485 --> 00:13:45.520
qui est une très bonne source.

00:13:45.520 --> 00:13:48.100
Il a une ventilation de
tous vos opérateurs et tout.

00:13:48.100 --> 00:13:49.930
J'ai donc un lien vers elle là-bas
au fond pour vous.

00:13:49.930 --> 00:13:56.605
ouais c'est effectivement la cartographie

00:13:56.605 --> 00:14:02.170
votre idée observable de

00:14:02.170 --> 00:14:03.925
les mêmes choses que vous pouvez
faire avec un itérateur.

00:14:03.925 --> 00:14:05.635
Il y a presque un parfait

00:14:05.635 --> 00:14:08.560
comparaisons en tête à tête
là, quand vous itérer.

00:14:08.560 --> 00:14:11.605
Donc un itérateur est comme IEnumerator.

00:14:11.605 --> 00:14:13.945
C'est l'équivalent.

00:14:13.945 --> 00:14:18.085
IEnumerator est ce qui est équivalent
à IObservable, fondamentalement.

00:14:18.085 --> 00:14:19.750
Donc, tout ce que vous pouvez
faire à un IEnumerator,

00:14:19.750 --> 00:14:21.355
vous pouvez le faire à un IObservable.

00:14:21.355 --> 00:14:23.410
Donc, c'était comme se rappeler
lorsque Link est venu

00:14:23.410 --> 00:14:25.990
et tout le monde était
super excité par

00:14:25.990 --> 00:14:28.225
Lien comme Lien sur les objets et

00:14:28.225 --> 00:14:31.510
Lien vers SQL et puis ils ont été
moins excité s'il y a link to SQL,

00:14:31.510 --> 00:14:33.800
mais Link était si excitant.

00:14:36.960 --> 00:14:41.260
Si efficacement vous avez votre
données récupérées qui est la prochaine, onNext.

00:14:41.260 --> 00:14:44.650
Ainsi, comme chacune de vos données
points viennent à travers.

00:14:44.650 --> 00:14:47.920
C'est là qu'il s'arrête jusqu'à l'endroit où

00:14:47.920 --> 00:14:52.030
Les observables deviennent plus
passionnant que vos événements.

00:14:52.030 --> 00:14:54.550
Donc, vous obtenez ces autres choses.

00:14:54.550 --> 00:14:56.875
Donc, vous obtenez un air par exemple.

00:14:56.875 --> 00:15:02.770
Si votre événement que vous êtes
l'observation manifeste une exception,

00:15:02.770 --> 00:15:05.800
vous pouvez faire face à cela comme
partie de l'observable.

00:15:05.800 --> 00:15:09.340
Ainsi, dans le cadre du flux de données
l'opération, vous pouvez indiquer,

00:15:09.340 --> 00:15:12.970
hey il ya cet événement
par une exception.

00:15:12.970 --> 00:15:14.515
Ainsi, par exemple, une demande web.

00:15:14.515 --> 00:15:16.990
Si une demande web est en cours et qu'elle

00:15:16.990 --> 00:15:20.020
jette une exception parce que

00:15:20.020 --> 00:15:22.165
l'Internet descend ou
quelque chose de similaire à cela,

00:15:22.165 --> 00:15:24.850
alors vous pouvez attraper efficacement que

00:15:24.850 --> 00:15:28.645
et faire face à cela
dans cette construction.

00:15:28.645 --> 00:15:29.920
Donc, il rend votre code beaucoup

00:15:29.920 --> 00:15:35.695
plus robuste et puis vous
aussi avoir cette idée de

00:15:35.695 --> 00:15:39.760
l'achèvement où vous pouvez tirer si

00:15:39.760 --> 00:15:43.345
quelqu'un a indiqué que

00:15:43.345 --> 00:15:45.790
ils ne se soucient plus
sur les points de données,

00:15:45.790 --> 00:15:47.725
vous pouvez alors agir en fonction de cela.

00:15:47.725 --> 00:15:50.590
Toutes ces choses
devenir des caractéristiques de

00:15:50.590 --> 00:15:54.070
comment vous interagissez avec vos données.

00:15:54.070 --> 00:16:01.760
Alors, voici un peu plus
points de comparaison.

00:16:06.120 --> 00:16:09.070
Donc, ceci est également tiré de ReactiveX.

00:16:09.070 --> 00:16:13.030
Comme vous pouvez le voir ici, vous avez votre
Itérable qui est votre défaut,

00:16:13.030 --> 00:16:14.890
donc c'est comme votre IEnumerator et

00:16:14.890 --> 00:16:16.860
vous avez raison qui
est votre IObservable.

00:16:16.860 --> 00:16:19.150
Donc, on obtient des données
de mémoire locale,

00:16:19.150 --> 00:16:20.210
donc ça va être peut-être comme un

00:16:20.210 --> 00:16:21.890
opération synchrone où vous venez de

00:16:21.890 --> 00:16:23.870
vos données sont réalisées à

00:16:23.870 --> 00:16:26.240
le haut et vous avez raison
on est du réseau,

00:16:26.240 --> 00:16:29.580
il peut s'avérer plus lent d'alimenter les données.

00:16:29.580 --> 00:16:32.915
Donc là, vous pouvez voir
vous obtenez ces mêmes idées

00:16:32.915 --> 00:16:37.350
sur vos flux d'événements qui
c'est juste, c'est super-puissant.

00:16:37.870 --> 00:16:42.940
Des trucs soignés. D'accord.

00:16:42.940 --> 00:16:45.450
Dénoncons comment le

00:16:45.450 --> 00:16:48.610
blocs de construction de
vos IObservables un peu ici.

00:16:50.010 --> 00:16:54.250
Donc, c'est l'idée de base de
comment vous construisez IObservable.

00:16:54.250 --> 00:16:57.205
Donc, comme vous le voyez dans
cette première étape là-bas,

00:16:57.205 --> 00:17:01.940
vous voyez le familier s'abonner
et se désabonner,

00:17:03.840 --> 00:17:07.450
ce n'est pas si excitant,
c'est juste de passage à travers

00:17:07.450 --> 00:17:10.390
différentes fonctions à l'observateur,

00:17:10.390 --> 00:17:11.830
afin que l'observateur sait comment traiter

00:17:11.830 --> 00:17:14.185
avec abonnements et désabonnements,

00:17:14.185 --> 00:17:18.250
afin qu'il puisse conteneuriser que
comportement au sein de l'IObservable.

00:17:18.250 --> 00:17:26.185
Donc, voici le comparatif
versions de ceux-ci,

00:17:26.185 --> 00:17:29.515
de ce que ceux-ci représentent.

00:17:29.515 --> 00:17:34.690
Donc, souscrire est effectivement
invoquer ce gars haut,

00:17:34.690 --> 00:17:37.840
le haut on a cliqué
et en disant: «D'accord,

00:17:37.840 --> 00:17:40.090
maintenant je me soucie de mes événements », et puis

00:17:40.090 --> 00:17:43.000
le bas là-bas
se débarrasse maintenant,

00:17:43.000 --> 00:17:45.715
qui est alors désabonner.

00:17:45.715 --> 00:17:48.730
C'est là que ça commence
pour devenir vraiment puissant,

00:17:48.730 --> 00:17:54.535
parce que vous avez
toute cette représentation

00:17:54.535 --> 00:17:58.210
est encapsulé dans le modèle familier.

00:17:58.210 --> 00:18:01.810
Donc, vous avez IDisposable
que nous avons tous utilisé,

00:18:01.810 --> 00:18:10.080
et nous avons des structures de données logiques

00:18:10.080 --> 00:18:11.310
et les moyens que nous pouvons utiliser

00:18:11.310 --> 00:18:14.760
ceux qui sont plus efficaces que
il suffit de dire désabonner.

00:18:14.760 --> 00:18:18.700
Donc, certains vraiment cool
façons de le faire,

00:18:18.700 --> 00:18:20.680
vous pouvez facilement gérer
ces temps de vie.

00:18:20.680 --> 00:18:25.359
Alors rappelez-vous avant où vous avez
pour s'assurer de se désabonner,

00:18:25.359 --> 00:18:28.600
donc comme dans Xamarin Forms par exemple,

00:18:28.600 --> 00:18:32.590
si vous changez un élément
ou si quelque chose de nouveau vient

00:18:32.590 --> 00:18:34.210
en ce que vous voulez vous abonner à

00:18:34.210 --> 00:18:36.325
et vous ne vous souciez pas
la vieille chose plus,

00:18:36.325 --> 00:18:40.000
vous devez faire cette chose où
vous vous désabonner de l'ancien,

00:18:40.000 --> 00:18:41.290
s'abonner à la nouvelle,

00:18:41.290 --> 00:18:44.920
puis aussi votre point de disposer ont

00:18:44.920 --> 00:18:48.955
pour vous assurer que vous vous désabonnez
de ces événements aussi.

00:18:48.955 --> 00:18:50.650
Donc, c'est ce qui est bien,

00:18:50.650 --> 00:18:57.070
est que tout votre événement
système de gestion de l'observation

00:18:57.070 --> 00:19:00.055
peut être articulé
par le biais de jetables.

00:19:00.055 --> 00:19:02.740
Nous agissons à cela et beaucoup
de ces choses ici

00:19:02.740 --> 00:19:05.215
J'aimerais qu'ils tirent
dans the.Net Cadre,

00:19:05.215 --> 00:19:08.290
mais pour l'instant, en

00:19:08.290 --> 00:19:11.440
RéactifX vous avez ces choses
comme CompositeDisposable.

00:19:11.440 --> 00:19:13.450
Donc, l'idée qu'il ya
vous pouvez agréger

00:19:13.450 --> 00:19:17.035
tous vos jetables dans
une structure de données unique,

00:19:17.035 --> 00:19:20.260
et puis cette structure de données maintenant,

00:19:20.260 --> 00:19:22.225
vous pouvez juste disposer d'une fois,

00:19:22.225 --> 00:19:26.125
une fois la durée de vie de
la classe contenant a disparu,

00:19:26.125 --> 00:19:28.540
et maintenant tout votre événement
gestion est prise en charge.

00:19:28.540 --> 00:19:33.310
Ainsi, vous pouvez attacher votre
PropertyChanged abonnements là-bas,

00:19:33.310 --> 00:19:37.570
vos abonnements TextChanged,
et puis vous vous en débarrassez.

00:19:37.570 --> 00:19:38.650
Donc, c'est soigné parce que vous obtenez

00:19:38.650 --> 00:19:44.200
ces concepts d'objet qui
vous pouvez postuler à vos événements,

00:19:44.200 --> 00:19:48.740
donc c'est sympa, j'aime ça.

00:19:51.900 --> 00:19:55.030
Par exemple, comme si j'étais
parler avant,

00:19:55.030 --> 00:19:57.430
où vous avez une instance

00:19:57.430 --> 00:19:59.725
où vous avez un vieil élément
que vous êtes abonné à,

00:19:59.725 --> 00:20:01.000
Je veux dire un nouvel élément vient

00:20:01.000 --> 00:20:04.690
dans de sorte que vous ne vous souciez pas de
l'ancien plus.

00:20:04.690 --> 00:20:06.310
Donc, il a comme ces concepts cool

00:20:06.310 --> 00:20:08.110
ici avec comme une élimination en série,

00:20:08.110 --> 00:20:09.910
où tout ce que vous
attribuer à cette volonté

00:20:09.910 --> 00:20:12.250
disposer automatiquement
de la chose avant elle.

00:20:12.250 --> 00:20:14.980
Donc, dans ces idées ici,

00:20:14.980 --> 00:20:16.900
vous n'avez pas à

00:20:16.900 --> 00:20:19.690
se désabonner pour ce qui est entré dans
là, ce qui est vraiment soigné.

00:20:19.690 --> 00:20:23.530
Mais vous savez que c'est
la nouvelle chaleur qui vous tient à cœur,

00:20:23.530 --> 00:20:25.390
et une fois que ça arrive,

00:20:25.390 --> 00:20:28.735
vous venez de se débarrasser de
tout ce qu'il y avait avant,

00:20:28.735 --> 00:20:30.370
de sorte que vous permet de mettre en place

00:20:30.370 --> 00:20:36.470
ces expressions vraiment cool
de ce que vous voulez faire.

00:20:37.320 --> 00:20:41.770
Parce que beaucoup de choses avec
Réactif qui est vraiment agréable,

00:20:41.770 --> 00:20:47.560
est d'avoir toute votre intention
en un seul endroit.

00:20:47.560 --> 00:20:51.050
La gestion de l'événement est
très basé sur le rappel,

00:20:52.080 --> 00:20:56.320
vous n'obtenez pas dans les mauvais styles
comme un enfer de rappel total,

00:20:56.320 --> 00:20:58.645
mais c'est toujours gentil
de la même chose.

00:20:58.645 --> 00:21:01.330
C'est la gestion de rappel
et puis interagir

00:21:01.330 --> 00:21:03.760
tous ces rappels différents
scénarios lorsque vous avez

00:21:03.760 --> 00:21:06.665
la même chose avec la façon dont vous
gérer la durée de vie de celui-ci.

00:21:06.665 --> 00:21:13.470
Mais quelqu'un ici a-t-il fait
Xamarin Forme des trucs?

00:21:13.470 --> 00:21:17.050
Je suis juste la cartographie
modélisations logiques ici.

00:21:17.050 --> 00:21:20.455
Donc, vous avez cette idée maintenant où

00:21:20.455 --> 00:21:25.690
la façon dont vous pouvez

00:21:25.690 --> 00:21:27.250
gérer l'ensemble du cycle de vie de

00:21:27.250 --> 00:21:30.635
quelque chose est juste à droite
là dans cette partie du milieu,

00:21:30.635 --> 00:21:33.840
et c'est tout ce que vous avez à faire.

00:21:33.840 --> 00:21:36.315
Une fois que c'est réglé là-bas,

00:21:36.315 --> 00:21:40.635
maintenant chaque fois que vous entrez et
vous avez un changement d'élément,

00:21:40.635 --> 00:21:42.650
et vous ne vous souciez que
sur le nouvel élément,

00:21:42.650 --> 00:21:47.230
l'attribution de nouvelles causes jetables
le précédent à disposer,

00:21:47.230 --> 00:21:49.990
alors maintenant tous vos événements
sont totalement câblés,

00:21:49.990 --> 00:21:52.645
et puis maintenant vous commencez
câblage de vos nouveaux.

00:21:52.645 --> 00:21:53.860
Puis dans votre disposé,

00:21:53.860 --> 00:21:56.260
vous avez juste un seul
disposer en série qui est

00:21:56.260 --> 00:22:01.750
votre niveau de classe géré ressource
dont vous vous débarrassez.

00:22:01.750 --> 00:22:06.880
Donc maintenant il n'y a pas

00:22:06.880 --> 00:22:10.480
cette complexité de la gestion en tant que
dans la mesure où votre manipulation préalable.

00:22:10.480 --> 00:22:13.300
Donc, c'était en fait
la première chose qui m'a mis dans

00:22:13.300 --> 00:22:17.630
La programmation réactive a été
la gestion jetable,

00:22:18.900 --> 00:22:22.150
Je pense que c'était comme un an avant
J'avais même utilisé autre chose.

00:22:22.150 --> 00:22:25.540
Juste parce que j'ai eu un Silverlight
application qui avait

00:22:25.540 --> 00:22:30.775
certains problèmes d'abonnement et
puis je suis tombé sur ce genre de choses,

00:22:30.775 --> 00:22:32.815
donc ce truc est cool,

00:22:32.815 --> 00:22:34.870
les jetables me rendent super heureux.

00:22:34.870 --> 00:22:37.390
Donc, ceux-ci sont encore la cartographie de certains des

00:22:37.390 --> 00:22:40.120
ces idées qui sont
vraiment soigné, donc comme ici,

00:22:40.120 --> 00:22:42.700
rappelez-vous avant quand vous
voulait ne s'abonner qu'à

00:22:42.700 --> 00:22:45.445
que l'événement et vous seul
voulait le voir une fois?

00:22:45.445 --> 00:22:48.640
Avec Reactive, vous pouvez faire

00:22:48.640 --> 00:22:52.045
ce concept entier ici
avec cette seule expression.

00:22:52.045 --> 00:22:54.160
Donc tout cela dit,

00:22:54.160 --> 00:22:58.839
"Je ne veux qu'une valeur de
cette propriété a changé,

00:22:58.839 --> 00:23:02.680
et puis à ce point, je
vous voulez vous débarrasser de lui.

00:23:02.680 --> 00:23:05.335
Donc je veux dire que c'est génial juste là,

00:23:05.335 --> 00:23:07.555
Prenez-en un, puis changez,

00:23:07.555 --> 00:23:10.180
ce qui est un peu délicat à
comprendre, mais ceux-ci sont

00:23:10.180 --> 00:23:13.270
juste assez de raisons
de l'utiliser pour toujours,

00:23:13.270 --> 00:23:15.340
c'est bien, j'aime ça.

00:23:15.340 --> 00:23:22.210
Donc, c'est la ventilation de
comment fonctionnent les opérations.

00:23:22.210 --> 00:23:31.670
J'ai donc quelques démos de
réaliser cela dans le code un peu plus,

00:23:33.360 --> 00:23:39.970
mais je voulais donner un peu de concept
préparation à vous aussi,

00:23:39.970 --> 00:23:45.700
à certains des types de réactifs
structures que nous utilisons,

00:23:45.700 --> 00:23:47.980
juste pour qu'il soit un peu plus logique.

00:23:47.980 --> 00:23:50.500
Donc, l'une des façons dont vous décrivez des choses

00:23:50.500 --> 00:23:53.185
avec Reactive est par
en utilisant des diagrammes de marbre,

00:23:53.185 --> 00:23:55.075
donc il ya ces idées de voir

00:23:55.075 --> 00:24:01.405
votre entrée et ce que la sortie est.

00:24:01.405 --> 00:24:03.760
Donc, les deux premiers ici,

00:24:03.760 --> 00:24:10.285
c'est la langue vernaculaire pour
la plupart des informations réactives,

00:24:10.285 --> 00:24:14.800
donc chaque fois que vous voyez
Opérateurs réactifs décrits,

00:24:14.800 --> 00:24:16.330
ils sont toujours décrits
dans ce format.

00:24:16.330 --> 00:24:19.810
Donc, l'idée ici est que
les deux premières choses sont les flux de données,

00:24:19.810 --> 00:24:23.480
et puis le bas est
ce que votre abonné voit.

00:24:24.420 --> 00:24:27.519
La fusion serait de deux abonnés,

00:24:27.519 --> 00:24:29.980
donc comme si vous vous abonnez
pour dire un événement TextChanged

00:24:29.980 --> 00:24:36.175
sur une boîte de nom d'utilisateur et un
boîte de mot de passe par exemple,

00:24:36.175 --> 00:24:38.620
n'importe quand l'un ou l'autre de
ceux changer c'est

00:24:38.620 --> 00:24:40.690
à quoi ressemblerait votre sortie.

00:24:40.690 --> 00:24:43.360
Donc, ce sont quelques-uns des
les opérateurs que j'ai utilisés dans la démo,

00:24:43.360 --> 00:24:44.620
donc je voulais juste

00:24:44.620 --> 00:24:50.350
pour s'assurer qu'ils étaient
compris avant que je passe à autre chose.

00:24:50.350 --> 00:24:53.350
Donc Filtre, c'est
fondamentalement comme un endroit,

00:24:53.350 --> 00:24:57.460
donc sur le lien vers IEnumerable,

00:24:57.460 --> 00:25:00.280
c'est comme un endroit.

00:25:00.280 --> 00:25:02.260
Donc, efficacement tout événement qui vient

00:25:02.260 --> 00:25:05.810
à travers, assez simple pour comprendre.

00:25:05.850 --> 00:25:09.100
Debounce, donc c'est
l'autre fonctionnalité vraiment cool,

00:25:09.100 --> 00:25:11.395
donc c'est étranglant vos entrées.

00:25:11.395 --> 00:25:13.570
Donc, dans cet exemple, ce qu'ils sont

00:25:13.570 --> 00:25:16.210
démontrant ici est
qu'ils ne veulent que

00:25:16.210 --> 00:25:17.710
la valeur la plus récente à venir

00:25:17.710 --> 00:25:21.025
après une certaine
temps fixé.

00:25:21.025 --> 00:25:25.840
Donc vous pouvez voir qu'il y a un décalage
entre un et cinq parce que deux,

00:25:25.840 --> 00:25:27.745
trois, et quatre sont

00:25:27.745 --> 00:25:30.280
se passe si près l'un de l'autre
que cinq est en train de sortir.

00:25:30.280 --> 00:25:33.910
C'est donc la quintessence
exemple pour des trucs réactifs,

00:25:33.910 --> 00:25:36.850
donc les cas où les utilisateurs sont

00:25:36.850 --> 00:25:39.400
faire comme la recherche avec

00:25:39.400 --> 00:25:42.305
Google quand ils tapent
dans leur Autocomplete,

00:25:42.305 --> 00:25:45.220
mais vous ne voulez pas aimer coup de pied
hors d'une demande web à chaque fois,

00:25:45.220 --> 00:25:48.640
de sorte que c'est effectivement ce que
cela démontre,

00:25:48.640 --> 00:25:50.305
dont nous avons un exemple.

00:25:50.305 --> 00:25:56.640
Puis TakeUntil est
le dernier opérateur que j'utilise,

00:25:56.640 --> 00:25:58.110
takeUntil est donc vraiment soigné,

00:25:58.110 --> 00:26:01.170
parce que c'est par exemple
ressembler à une demande web.

00:26:01.170 --> 00:26:04.605
Donc, disons une demande web
commence,

00:26:04.605 --> 00:26:07.210
et puis l'utilisateur
commence à taper à nouveau,

00:26:07.210 --> 00:26:09.880
ou ils disent annuler,

00:26:09.880 --> 00:26:11.560
comme s'ils ne voulaient pas
cela se produit plus,

00:26:11.560 --> 00:26:16.360
de sorte que tous ceux qui sont un autre
points d'événement que vous pouvez promulguer,

00:26:16.360 --> 00:26:19.465
et à ce moment-là, il coupe
hors de votre flux plus.

00:26:19.465 --> 00:26:22.375
Donc, c'est comme un vraiment
façon simple de dire coupé,

00:26:22.375 --> 00:26:25.940
si vous ne voulez pas une demande web
ou quelque chose comme ça pour finir.

00:26:25.940 --> 00:26:32.400
Donc, c'est la ventilation
de la substance observable,

00:26:32.400 --> 00:26:35.470
Alors laissez-moi passer,

00:26:36.080 --> 00:26:39.380
tenir sur une seconde.

00:26:39.380 --> 00:26:52.660
Cool, voyons voir.

00:26:53.540 --> 00:26:55.875
C'est trop petit ?

00:26:55.875 --> 00:26:57.610
Oui, c'est vrai.

00:26:58.710 --> 00:27:01.330
C'est des choses que vous
faire quand vous vous rendez compte

00:27:01.330 --> 00:27:04.000
que vous n'avez jamais fait
ceux-ci sur les démos avant,

00:27:04.000 --> 00:27:07.525
En fait, je n'ai jamais augmenté
sa taille de police sur Obs Mac avant.

00:27:07.525 --> 00:27:16.300
Voyons. J'essaie
faire mes trucs Windows ici,

00:27:16.300 --> 00:27:20.540
voilà, je suppose que c'est tout.

00:27:22.580 --> 00:27:26.610
Très bien, j'essayais de
mes gestes sur le pad.

00:27:26.610 --> 00:27:27.630
J'ai fait le balayage.

00:27:27.630 --> 00:27:28.650
J'ai fait deux doigts,

00:27:28.650 --> 00:27:32.670
C'est moi qui l'ai fait. Je ne sais pas.

00:27:32.670 --> 00:27:35.280
Je ne suis pas arrivé sur elle, je suppose.

00:27:35.280 --> 00:27:45.015
Alors voilà. D'accord, oui.

00:27:45.015 --> 00:27:46.740
Alors que vous démarrez les fenêtres
où vous venez de frapper

00:27:46.740 --> 00:27:48.615
contrôle et le diviser.

00:27:48.615 --> 00:27:51.910
Très bien pour que tout le monde
peut le voir. D'accord?

00:27:52.070 --> 00:27:55.410
Alors laissez-moi exécuter la démo réelle

00:27:55.410 --> 00:27:59.895
rapide juste pour que nous ayons le contexte
de ce que nous faisons ici.

00:27:59.895 --> 00:28:02.640
Donc, c'est un peu
une application de base.

00:28:02.640 --> 00:28:08.355
C'est juste une idée de login logout.

00:28:08.355 --> 00:28:14.265
Ouais, donc ci-dessous j'ai un ensemble
d'événements qui se produisent,

00:28:14.265 --> 00:28:21.690
de sorte que c'est effectivement
le flux de données des observables.

00:28:21.690 --> 00:28:23.970
Donc, tous les événements qui sont
se passe avec les observables.

00:28:23.970 --> 00:28:25.365
Nous avons donc ici log-in.

00:28:25.365 --> 00:28:27.240
Donc, c'est l'utilisateur et mot de passe

00:28:27.240 --> 00:28:28.665
que j'aurais dû mettre
un journal des lieux.

00:28:28.665 --> 00:28:34.095
Mais donc l'idée ici vous
peut voir si je frappe une lettre.

00:28:34.095 --> 00:28:36.509
y. Alors a frappé une lettre

00:28:36.509 --> 00:28:39.090
et à ce moment-là, c'est
validation de l'entrée.

00:28:39.090 --> 00:28:41.175
Maintenant, vous pouvez voir que
il y a un peu de ce retard.

00:28:41.175 --> 00:28:43.935
Oui? Donc, si je frappe
"O" il y a un retard.

00:28:43.935 --> 00:28:46.170
Donc, l'idée derrière
c'est que vous êtes

00:28:46.170 --> 00:28:49.455
pas- c'est que débouncing
dont vous parlez.

00:28:49.455 --> 00:28:54.945
Donc, si je tape dans le "Nom d'utilisateur"
et le mot de passe.

00:28:54.945 --> 00:28:59.310
y. Vous pouvez voir qu'une fois
que la validation se produit.

00:28:59.310 --> 00:29:01.710
Donc, c'est juste que nous allons sorte de pause
en bas de ces structures une fois que je

00:29:01.710 --> 00:29:04.275
entrer là-dedans, mais c'est
l'idée derrière elle.

00:29:04.275 --> 00:29:08.910
ainsi. ouais. Tellement excitant.

00:29:08.910 --> 00:29:11.955
Maintenant, nous avons une simulation pour la connexion.

00:29:11.955 --> 00:29:14.250
Donc, l'idée ici, je clique sur "Login".

00:29:14.250 --> 00:29:18.840
Il commence une demande web, puis
à ce moment-là, vous pouvez vous déconnecter.

00:29:18.840 --> 00:29:21.870
Donc, et il ya une sorte de

00:29:21.870 --> 00:29:26.415
supplémentaire nous allons voir combien de fois
il faut avant que cela ne se déclenche.

00:29:26.415 --> 00:29:30.090
J'ai donc un randomiseur
là-dedans au hasard

00:29:30.090 --> 00:29:35.415
générer des erreurs. Voilà.

00:29:35.415 --> 00:29:38.400
cool. Donc, vous pouvez voir ici ce que

00:29:38.400 --> 00:29:41.775
se passe, c'est que je
cliqué sur le "Login".

00:29:41.775 --> 00:29:44.535
Il a généré une exception.

00:29:44.535 --> 00:29:47.895
Donc, comme l'exception Demande Web.

00:29:47.895 --> 00:29:51.630
Puis il a dit ok nous allons juste
réessayez la demande Web.

00:29:51.630 --> 00:29:59.640
Puis à ce moment-là, il
puis m'a connecté, non?

00:29:59.640 --> 00:30:02.655
Puis l'autre aspect
de ce qui est moi.

00:30:02.655 --> 00:30:05.070
Comme disons que l'utilisateur
veut l'annuler.

00:30:05.070 --> 00:30:09.100
Donc, s'ils cliquent sur "Login"
ils peuvent cliquer sur "Annuler".

00:30:09.350 --> 00:30:13.470
Là, vous pouvez voir maintenant ce n'est pas
traitement plus long des données.

00:30:13.470 --> 00:30:16.035
Oui? Donc, parce que

00:30:16.035 --> 00:30:18.885
il ya un genre d'opération
d'annuler cela.

00:30:18.885 --> 00:30:23.805
Donc, c'est à la démo.

00:30:23.805 --> 00:30:25.815
Ouais, donc c'est l'idée derrière.

00:30:25.815 --> 00:30:27.900
C'est le code.

00:30:27.900 --> 00:30:32.160
Ouais, donc l'idée

00:30:32.160 --> 00:30:34.965
derrière cela à sorte de
décomposer les structures.

00:30:34.965 --> 00:30:37.935
Puisque nous avons tous vu beaucoup
de ces choses, c'est que

00:30:37.935 --> 00:30:41.340
c'est la composability
aspect des observables.

00:30:41.340 --> 00:30:43.890
L'aspect composability
est que vous avez

00:30:43.890 --> 00:30:46.920
cette représentation de vos événements en tant que

00:30:46.920 --> 00:30:50.730
ces flux de données uniques
que vous pouvez alors commencer à

00:30:50.730 --> 00:30:55.845
intermix pour articuler
le comportement de votre application.

00:30:55.845 --> 00:31:01.050
Donc, si nous avons l'application ce qui sont
tous les flux de l'événement ici.

00:31:01.050 --> 00:31:03.360
Les flux d'événements sont
nous avons l'entrée sur

00:31:03.360 --> 00:31:07.065
le haut que nous avons l'entrée
sur les deuxièmes champs.

00:31:07.065 --> 00:31:10.320
En tant que types d'utilisateurs que nous avons
le bouton de connexion cliquez.

00:31:10.320 --> 00:31:12.975
Nous avons le clic de bouton Annuler
et nous avons comme la demande Web.

00:31:12.975 --> 00:31:17.205
Nous avons donc effectivement
cinq événements différents.

00:31:17.205 --> 00:31:20.550
Des flux que nous devons décrire.

00:31:20.550 --> 00:31:28.545
Donc, nous pouvons briser ces
dans leurs parties réactives.

00:31:28.545 --> 00:31:32.145
Donc, ce sont tous assez peu excitant.

00:31:32.145 --> 00:31:37.050
C'est la même chose que vous
vu avant qui est essentiellement

00:31:37.050 --> 00:31:39.180
juste dire Hey je veux créer ce

00:31:39.180 --> 00:31:42.630
observable qui écoute
à l'événement cliqué.

00:31:42.630 --> 00:31:46.095
Donc, c'est l'aspect central
de cela c'est excitant.

00:31:46.095 --> 00:31:51.825
Nous créons donc un
chacun de ces différents éléments.

00:31:51.825 --> 00:31:54.030
Nous avons notre connexion.

00:31:54.030 --> 00:31:55.470
C'est là qu'ils cliquent.

00:31:55.470 --> 00:31:56.805
Nous avons notre déconnexion.

00:31:56.805 --> 00:31:58.440
C'est là qu'ils se déconnectent.

00:31:58.440 --> 00:32:01.785
On a notre annulation. C'est
quand ils cliquent sur "Annuler".

00:32:01.785 --> 00:32:06.750
Nous avons le changement de texte
ici qui est quand ils sont

00:32:06.750 --> 00:32:09.000
tapant dans le nom d'utilisateur et nous avons

00:32:09.000 --> 00:32:12.090
le mot de passe ici quand ils sont
taper le mot de passe.

00:32:12.090 --> 00:32:15.300
Ensuite, nous faisons
un faux appel de demande Web.

00:32:15.300 --> 00:32:17.670
Donc, c'est juste une démonstration.

00:32:17.670 --> 00:32:20.565
C'est essentiellement juste
attendre deux secondes.

00:32:20.565 --> 00:32:22.440
Puis une fois qu'il a fini, il génère

00:32:22.440 --> 00:32:26.265
une erreur si certains aléatoires
nombre équivaut à deux.

00:32:26.265 --> 00:32:35.010
ouais. C'est notre application.

00:32:35.010 --> 00:32:38.250
C'est en observable
représentation de la représentation des

00:32:38.250 --> 00:32:41.985
tous les événements qui peuvent se produire
dans l'application, non?

00:32:41.985 --> 00:32:43.860
Alors maintenant, c'est là que

00:32:43.860 --> 00:32:47.680
l'aspect composability vient
dans le jeu qui est vraiment cool.

00:32:48.500 --> 00:32:51.150
Maintenant, tous ces
différents observables

00:32:51.150 --> 00:32:53.220
prendre une vie propre.

00:32:53.220 --> 00:33:00.060
Ainsi, l'ensemble des
la logique que vous voyez

00:33:00.060 --> 00:33:06.990
il est incarné avec un assez
simple quantité de code, non?

00:33:06.990 --> 00:33:12.780
Voici donc notre code de validation.

00:33:12.780 --> 00:33:14.940
Donc maintenant ce que nous faisons est
nous construisons

00:33:14.940 --> 00:33:18.810
observables supplémentaires sur
ces autres observables.

00:33:18.810 --> 00:33:21.990
Oui? Donc, c'est ce qui est
l'aspect composability de celui-ci.

00:33:21.990 --> 00:33:23.640
Donc, le premier est que nous

00:33:23.640 --> 00:33:26.520
dire d'accord, nous voulons un
observable s'authentififier.

00:33:26.520 --> 00:33:29.580
L'observable authentifié
est l'utilisateur cliquant

00:33:29.580 --> 00:33:33.060
"Login" et en cliquant
hors "Demande Web".

00:33:33.060 --> 00:33:39.090
Alors maintenant, nous avons composé ces deux
idées d'événements observables.

00:33:39.090 --> 00:33:42.870
Nous avons maintenant fusionné ces données
flux avec déconnexion.

00:33:42.870 --> 00:33:47.250
Donc, si un utilisateur clique sur "Logout"
alors c'est dire "Hey,

00:33:47.250 --> 00:33:48.735
Je veux que vous vous déconnectiez.

00:33:48.735 --> 00:33:54.480
Donc, nous avons l'ensemble
état d'authentification de

00:33:54.480 --> 00:34:00.525
l'application représentée par
un nouvel authentifié observable.

00:34:00.525 --> 00:34:02.295
Authentifié observable.

00:34:02.295 --> 00:34:05.295
Donc, c'est le seul observable
nous nous soucions à ce stade.

00:34:05.295 --> 00:34:07.530
Donc, c'est ainsi que maintenant nous pouvons utiliser que

00:34:07.530 --> 00:34:09.540
observable n'importe où ailleurs où nous

00:34:09.540 --> 00:34:14.940
veulent poser des questions sur ce qui est
l'utilisateur authentifié.

00:34:14.940 --> 00:34:18.190
Vous savez ce qui est besoin.

00:34:19.910 --> 00:34:22.620
Ensuite, nous avons ici notre validation.

00:34:22.620 --> 00:34:24.720
Notre validation est une composition de

00:34:24.720 --> 00:34:29.410
notre nom d'utilisateur et notre mot de passe
là, ce qui est agréable.

00:34:29.570 --> 00:34:33.645
Donc, c'est essentiellement entrer en vigueur.

00:34:33.645 --> 00:34:35.894
Il est dit "Hey,

00:34:35.894 --> 00:34:38.909
ce sont les points de données
qui représentent la validité.

00:34:38.909 --> 00:34:43.080
Il transforme ces événements en un

00:34:43.080 --> 00:34:47.910
vraie ou fausse valeur que nous
peut maintenant utiliser pour dire: «D'accord.

00:34:47.910 --> 00:34:53.860
Quel est l'état des événements
qui ont été à venir? "

00:34:55.190 --> 00:34:58.515
Alors, nous allons maintenant

00:34:58.515 --> 00:35:01.455
mis ensemble- Maintenant, nous pouvons mettre
toutes ces choses ensemble.

00:35:01.455 --> 00:35:03.120
C'est là que le genre de
comme le fonctionnel

00:35:03.120 --> 00:35:05.295
aspect de programmation réactif
entre en jeu.

00:35:05.295 --> 00:35:08.880
Nous pouvons maintenant mettre tous ces différents
observables ensemble dans

00:35:08.880 --> 00:35:10.485
un joli petit endroit

00:35:10.485 --> 00:35:15.255
ici qui décrit tout
qui va se passer.

00:35:15.255 --> 00:35:17.760
Donc, c'est la partie de
c'est vraiment soigné.

00:35:17.760 --> 00:35:22.995
Parce qu'avec cette
application que vous pouvez obtenir

00:35:22.995 --> 00:35:27.120
une perspective sur l'ensemble des

00:35:27.120 --> 00:35:31.710
la logique juste en étant juste
ici dans ce point de code.

00:35:31.710 --> 00:35:36.060
Il n'y a pas à
sauter autour ou quoi que ce soit.

00:35:36.060 --> 00:35:40.170
C'est un endroit immuable basé sur

00:35:40.170 --> 00:35:46.485
données immuables pour modifier
comment ces points de données fonctionnent.

00:35:46.485 --> 00:35:50.190
Donc, c'est bien parce que
c'est un moyen facile agréable.

00:35:50.190 --> 00:35:53.490
Donc, comme les données qui viennent
dans cette valeur de résultat ici

00:35:53.490 --> 00:35:57.450
est une structure immuable.

00:35:57.450 --> 00:36:00.435
Ensuite, sur la base de ces données, vous
savoir authentifié observable.

00:36:00.435 --> 00:36:02.760
Donc, ce que cela fait
ici dit ce qui est

00:36:02.760 --> 00:36:06.315
votre état d'authentification est de savoir si
vous êtes authentifié ou non.

00:36:06.315 --> 00:36:10.845
Valide, c'est dire si le
les informations d'identification qu'ils ont saisies comme sont valides.

00:36:10.845 --> 00:36:12.360
Ensuite, sur la base de cela,

00:36:12.360 --> 00:36:17.320
vous configurez la visibilité
de votre application.

00:36:20.170 --> 00:36:22.890
Ouais, donc vous pouvez mettre en place
comme la visibilité de

00:36:22.890 --> 00:36:26.200
votre demande. Donc c'est soigné.

00:36:28.340 --> 00:36:31.905
Voyons voir.

00:36:31.905 --> 00:36:34.350
J'ai une démo de plus très vite,

00:36:34.350 --> 00:36:36.820
juste un petit.

00:36:39.350 --> 00:36:43.725
Oups, un peu trop grand
y. Et voilà.

00:36:43.725 --> 00:36:45.345
Est-ce que tout le monde voit ça, d'accord ?

00:36:45.345 --> 00:36:50.400
ouais. D'accord. J'ai ces
comme GitHub repos.

00:36:50.400 --> 00:36:53.520
C'est en utilisant un peu
de l'interface réactive de l'interface,

00:36:53.520 --> 00:36:55.695
mais laissez-moi juste montrer.

00:36:55.695 --> 00:37:00.730
Cela a quelques échantillons différents
que vous pouvez jeter un oeil à.

00:37:02.360 --> 00:37:10.240
J'espère que ça va se faire. Vraiment
déjà en cours d'exécution? Voilà, c'est parti.

00:37:10.940 --> 00:37:14.980
Donc, beaucoup d'entre eux sont
choses simples que vous voyez.

00:37:15.050 --> 00:37:17.775
Regardons le
démo position depuis que nous sommes

00:37:17.775 --> 00:37:19.905
à court d'heure ici.

00:37:19.905 --> 00:37:21.900
Donc, l'idée de la démo position

00:37:21.900 --> 00:37:24.810
c'est que c'est vous suivez
votre pointeur de souris.

00:37:24.810 --> 00:37:30.780
Cela a un autre exemple populaire
pour les concepts réactifs.

00:37:30.780 --> 00:37:32.055
Alors tu pousses vers le bas.

00:37:32.055 --> 00:37:33.660
Il détecte que vous appuyez.

00:37:33.660 --> 00:37:34.740
Si vous déplacez votre souris,

00:37:34.740 --> 00:37:36.000
maintenant c'est détecter que vous avez déménagé,

00:37:36.000 --> 00:37:37.380
et puis vous lâcher, et il donne

00:37:37.380 --> 00:37:40.335
vous une agrégation de toutes vos données.

00:37:40.335 --> 00:37:49.380
Il est un peu cassé

00:37:49.380 --> 00:37:51.720
parce que j'ai besoin d'avoir
les descriptions,

00:37:51.720 --> 00:37:56.080
mais c'est vraiment soigné parce que
tout ce que vous avez à faire,

00:37:56.120 --> 00:37:58.905
vous avez votre pointeur pressé événement.

00:37:58.905 --> 00:38:01.200
Donc, vous avez le pointeur
presse qui dit,

00:38:01.200 --> 00:38:03.840
"Hé, j'ai appuyé sur la souris."

00:38:03.840 --> 00:38:06.840
Maintenant, une fois que cela a
arrivé, vous dites, "Ok,

00:38:06.840 --> 00:38:10.395
Je veux m'abonner à
le pointeur étant déplacé autour.

00:38:10.395 --> 00:38:14.170
Donc, c'est maintenant le pointeur
être déplacé.

00:38:14.240 --> 00:38:16.800
Comme il se déplace maintenant,

00:38:16.800 --> 00:38:20.085
vous tirez toutes ces données
ensemble ici,

00:38:20.085 --> 00:38:23.145
et puis l'opérateur de la liste des deux, ici,

00:38:23.145 --> 00:38:24.960
est maintenant en mesure de
agrégation de toutes ces données

00:38:24.960 --> 00:38:27.405
ensemble dans un seul ensemble de données.

00:38:27.405 --> 00:38:29.760
Puis ici, la prise jusqu'à ce que c'était

00:38:29.760 --> 00:38:32.220
la seule opération qui
nous montions ici.

00:38:32.220 --> 00:38:34.170
"Hé, d'accord, d'accord,
Je veux seulement que tu

00:38:34.170 --> 00:38:36.270
prendre ces données et dire
les pointeurs libérés.

00:38:36.270 --> 00:38:38.309
Donc, vous obtenez ce vraiment
interaction cool

00:38:38.309 --> 00:38:40.020
de tous ces événements à dire,

00:38:40.020 --> 00:38:41.940
parce que tout ce que vous vouliez vraiment
pour dire, c'est que je veux bouger

00:38:41.940 --> 00:38:44.130
la souris autour et quand
ils ont lâché la souris,

00:38:44.130 --> 00:38:45.810
Je veux toutes les données qui étaient là.

00:38:45.810 --> 00:38:47.160
Donc, vous pouvez obtenir tout cela

00:38:47.160 --> 00:38:50.505
représenté dans cette belle
petit abonnement ici.

00:38:50.505 --> 00:38:55.120
Donc, c'est l'un des
ces principaux exemples.

00:38:57.130 --> 00:39:03.360
Oui, donc c'est une amorce rapide
dans les concepts réactifs.

00:39:04.690 --> 00:39:08.940
Il y a beaucoup de
de bons cadres là-bas.

00:39:11.210 --> 00:39:16.740
Oups, pas utile. Et voilà.

00:39:16.740 --> 00:39:23.280
ouais. Donc, c'est l'idée derrière
la plupart des observables.

00:39:23.280 --> 00:39:25.530
Michael va parler
un peu plus sur l'utilisation

00:39:25.530 --> 00:39:28.545
ces cadres avec MVVM.

00:39:28.545 --> 00:39:32.880
Il y a beaucoup de très puissants
outils comme les données dynamiques.

00:39:32.880 --> 00:39:35.100
Sélectionnez les données dynamiques, c'est

00:39:35.100 --> 00:39:37.590
une plate-forme vraiment cool

00:39:37.590 --> 00:39:41.985
pour la superpuissance dans vos listes
avec des observables.

00:39:41.985 --> 00:39:43.890
Donc, l'idée est que vous pouvez

00:39:43.890 --> 00:39:46.995
essentiellement faire
tout et observable.

00:39:46.995 --> 00:39:49.660
Vous pouvez le signer,
Je ne le savais pas.

00:39:51.470 --> 00:39:53.610
Donc, je suppose que très vite,

00:39:53.610 --> 00:39:55.960
quelqu'un at-il des questions?

00:39:57.410 --> 00:40:00.720
Oui, Sam. Eh bien, oui.

00:40:00.720 --> 00:40:04.095
On va y aller. Nous allons
poser des questions d'environ 35 minutes.

00:40:04.095 --> 00:40:05.520
Alors, parlez de

00:40:05.520 --> 00:40:10.380
la divulgation de la
[inaudible] et tout ça.

00:40:10.380 --> 00:40:14.220
Discutez des raisons pour lesquelles les observables
sont mieux [inaudibles].

00:40:14.220 --> 00:40:20.460
Oui, donc je

00:40:20.460 --> 00:40:24.045
je dirais que je dirais parce que
la direction- Donc, la question était,

00:40:24.045 --> 00:40:25.680
avec la mémoire qui fuit,

00:40:25.680 --> 00:40:28.290
pourquoi est le fait qu'il retourne

00:40:28.290 --> 00:40:31.245
un meilleur jetable d'abord
dire la gestion de la mémoire?

00:40:31.245 --> 00:40:33.090
L'idée qu'il y a juste, oui,

00:40:33.090 --> 00:40:37.230
c'est le fait que
c'est la vie de

00:40:37.230 --> 00:40:43.665
l'observable est un aspect
de l'abonnement.

00:40:43.665 --> 00:40:46.920
Donc, quand vous vous abonnez
à elle, vous revenez,

00:40:46.920 --> 00:40:49.395
parce que chaque fois que vous obtenez
un jetable de quelque chose,

00:40:49.395 --> 00:40:51.270
vous savez que vous avez
pour s'en débarrasser.

00:40:51.270 --> 00:40:54.630
Comme si c'était le paradigme que nous utilisons.

00:40:54.630 --> 00:40:57.060
C'est l'idée.

00:40:57.060 --> 00:41:01.365
C'est qu'avec l'évent
en particulier pour les nouveaux programmeurs,

00:41:01.365 --> 00:41:03.660
ils vont toujours à
faire que comme une erreur

00:41:03.660 --> 00:41:07.700
où sont comme quelque chose

00:41:07.700 --> 00:41:08.810
va survivre à autre chose

00:41:08.810 --> 00:41:10.250
parce que vous devez comprendre cela.

00:41:10.250 --> 00:41:15.360
Mais un jetable est
un concept très basique.

00:41:15.360 --> 00:41:19.155
Donc, avoir cela dans le cadre
de l'abonnement

00:41:19.155 --> 00:41:22.860
rend votre gestion de la mémoire
scénarios plus faciles.

00:41:22.860 --> 00:41:25.440
ouais.

00:41:25.440 --> 00:41:26.940
D'autres questions ?

00:41:26.940 --> 00:41:28.727
ouais.

00:41:28.727 --> 00:41:35.250
[inaudible].

00:41:35.250 --> 00:41:39.060
Oui, c'est vrai. Donc la question était,

00:41:39.060 --> 00:41:41.985
pouvez-vous utiliser la programmation réactive

00:41:41.985 --> 00:41:45.060
avec des choses comme des tâches ou
programmation asynchrone?

00:41:45.060 --> 00:41:50.865
ouais. Donc, une tâche est effectivement
une notification en un point.

00:41:50.865 --> 00:41:53.355
Donc, quand vous avez une tâche,

00:41:53.355 --> 00:41:57.210
il ya trois points de données pour
une tâche qui est exactement comme

00:41:57.210 --> 00:42:02.175
notre itérateur quand nous avons indiqué.

00:42:02.175 --> 00:42:05.040
Donc, quand vous écrivez une tâche- D'accord,

00:42:05.040 --> 00:42:06.615
Je ne sais pas où c'est.
à venir. D'accord.

00:42:06.615 --> 00:42:08.190
Donc, quand vous avez une tâche,

00:42:08.190 --> 00:42:14.145
vous créez la tâche de sorte que c'est
vous l'avez au début,

00:42:14.145 --> 00:42:19.724
alors vous commencez la tâche
alors maintenant il est en cours d'exécution,

00:42:19.724 --> 00:42:23.355
et puis la tâche produit une valeur,

00:42:23.355 --> 00:42:26.445
c'est vos résultats point
qu'aucun d'entre nous ne tape,

00:42:26.445 --> 00:42:29.970
et puis il se termine à
l'achèvement de cela.

00:42:29.970 --> 00:42:31.440
Donc, à ce moment-là,

00:42:31.440 --> 00:42:35.190
vous avez un point de données observable.

00:42:35.190 --> 00:42:40.680
Donc jetable crée des choses

00:42:40.680 --> 00:42:42.900
qui travaillent exactement contre la tâche afin

00:42:42.900 --> 00:42:45.180
que vous pouvez créer un
observable contre la tâche.

00:42:45.180 --> 00:42:49.125
Alors ce qui va se passer, c'est quand
vous souscrivez à cette observable,

00:42:49.125 --> 00:42:54.494
est-il va effectivement commencer la tâche
et une fois que ça arrive,

00:42:54.494 --> 00:42:56.190
qui donne un coup de pied en arrière un résultat.

00:42:56.190 --> 00:42:59.655
Donc, cela produit une valeur
et puis il se termine.

00:42:59.655 --> 00:43:01.410
Alors c'est une autre chose
c'est vraiment super

00:43:01.410 --> 00:43:03.600
utile parce que si cette tâche échoue,

00:43:03.600 --> 00:43:05.040
vous obtenez vos affaires avec

00:43:05.040 --> 00:43:07.485
observables où vous
peut attraper l'exception.

00:43:07.485 --> 00:43:13.500
Ainsi, par exemple, les scénarios
comme un vide async, par exemple.

00:43:13.500 --> 00:43:16.575
Async vide est un non-problème
avec des observables.

00:43:16.575 --> 00:43:18.495
Vous n'avez jamais à vous soucier

00:43:18.495 --> 00:43:21.970
async vide Si vous êtes
faire des observables.

00:43:22.040 --> 00:43:26.520
Ainsi, par exemple, vous savez comment vous
peut-être que vous voulez commencer une tâche async

00:43:26.520 --> 00:43:28.050
d'un constructeur ou des choses comme

00:43:28.050 --> 00:43:30.060
qui ou ces questions de
ceux qui ont des observables,

00:43:30.060 --> 00:43:31.200
ce n'est même pas un scénario,

00:43:31.200 --> 00:43:34.320
parce que vous venez d'envelopper la tâche dans un

00:43:34.320 --> 00:43:36.180
observable et puis vous avez

00:43:36.180 --> 00:43:39.225
le comportement d'exception dans le cadre
de l'observable avec la tâche.

00:43:39.225 --> 00:43:40.710
Alors oui, ils fonctionnent.

00:43:40.710 --> 00:43:42.060
Ils sont parfaits pour les tâches.

00:43:42.060 --> 00:43:43.770
Alors là, j'oublie qui parle.

00:43:43.770 --> 00:43:46.260
Jeffrey ou quelque chose comme
qui fait une conversation à ce sujet;

00:43:46.260 --> 00:43:48.015
parler de la façon dont les tâches sont

00:43:48.015 --> 00:43:50.010
super mauvais et vous devriez
il suffit d'utiliser des observables.

00:43:50.010 --> 00:43:51.360
Mais oui, une fois que vous commencez à utiliser

00:43:51.360 --> 00:43:53.685
observables en particulier
dans votre code d'interface utilisateur,

00:43:53.685 --> 00:43:55.260
vous aurez effectivement juste mis

00:43:55.260 --> 00:43:57.420
une façade devant tous les
de vos tâches parce que

00:43:57.420 --> 00:44:02.080
il devient tellement plus simple de
gérer par des observables.

00:44:02.450 --> 00:44:04.905
D'autres questions ?

00:44:04.905 --> 00:44:07.840
Je reçois le shhh.

00:44:09.380 --> 00:44:12.870
Puis-je en prendre un de plus
question? non? D'accord, non.

00:44:12.870 --> 00:44:15.075
Je répondrai à votre
question juste après.

00:44:15.075 --> 00:44:17.340
cool. Alors oui, je suis Shane.

00:44:17.340 --> 00:44:20.500
C'est mes observables.