WEBVTT

00:00:00.000 --> 00:00:03.190
>> Va bene. ciao.
Come stanno tutti?

00:00:03.380 --> 00:00:08.280
Quarto alla strada attraverso
il nostro vertice Xam qui.

00:00:08.280 --> 00:00:12.870
Quindi sì, sono Shane
Neuville. L'ho scritto bene?

00:00:12.870 --> 00:00:17.715
sì. Shane Neuville. Sono
con il team Xamarin Forms.

00:00:17.715 --> 00:00:20.280
Prima di stare con Xamarin Forms,

00:00:20.280 --> 00:00:23.490
Ho lavorato una discreta quantità
con ReactiveUI.

00:00:23.490 --> 00:00:26.160
Quindi cerco ancora di difendere
che per quanto io

00:00:26.160 --> 00:00:29.310
può anche dall'interno di Microsoft.

00:00:29.310 --> 00:00:35.970
Quindi il discorso qui sta per essere
pesantemente sulle estensioni reattive,

00:00:35.970 --> 00:00:39.990
in particolare solo i concetti
dietro l'azionamento reattivo,

00:00:39.990 --> 00:00:42.990
come sono vicini agli eventi.

00:00:42.990 --> 00:00:44.975
Poi più tardi, Michael sta per fare

00:00:44.975 --> 00:00:47.600
un discorso più ampio su
mappatura su come

00:00:47.600 --> 00:00:52.040
MVVM e come alimentare
i vostri quadri per questo.

00:00:52.040 --> 00:00:56.055
Quindi, per iniziare con questo,

00:00:56.055 --> 00:00:59.305
quante persone hanno usato
Estensioni reattive,

00:00:59.305 --> 00:01:01.350
solo per ottenere, "Oh, ehi. È carino."?

00:01:01.350 --> 00:01:02.895
Ogni volta che chiedevo,
ci sono più mani.

00:01:02.895 --> 00:01:08.040
Quindi questo è un buon segno. Vediamo.

00:01:08.040 --> 00:01:12.250
Quindi, quante persone pensano che sto parlando
su JavaScript e ReactJS?

00:01:12.250 --> 00:01:15.250
Quel tipo laggiu', lui? Va bene.

00:01:16.130 --> 00:01:20.150
Così alcuni dei volgare
ha iniziato a chiarire pure.

00:01:20.150 --> 00:01:23.450
Qualcuno pensa che sto andando a
parlare di collezioni osservabili

00:01:23.450 --> 00:01:26.940
per circa un'ora? Lol Va bene.

00:01:26.940 --> 00:01:29.990
Quindi, lungo questo, questo fotogramma

00:01:29.990 --> 00:01:33.530
diventa un po 'meno
pertinenti man mano che i colloqui vanno avanti.

00:01:33.530 --> 00:01:37.580
C'era sicuramente
una certa confusione che è iniziata.

00:01:37.580 --> 00:01:39.980
Così mi ricordo il primo
volta che ho sentito parlare di ReactJS.

00:01:39.980 --> 00:01:42.955
Ho fatto RxJS per un po' di tempo.

00:01:42.955 --> 00:01:45.380
E 'stato circa cinque minuti
nella conversazione,

00:01:45.380 --> 00:01:48.695
Mi sono reso conto che non stavamo avendo
la stessa conversazione.

00:01:48.695 --> 00:01:51.890
Quindi non c'è davvero

00:01:51.890 --> 00:01:55.920
qualsiasi relazione ci oltre
le prime cinque lettere.

00:01:57.410 --> 00:02:01.105
L'angolare è iniziato
pesantemente utilizzando RxJS.

00:02:01.105 --> 00:02:03.260
Quindi angolare è probabilmente
più sinonimo

00:02:03.260 --> 00:02:05.870
con RxJS a questo punto, ma sì.

00:02:05.870 --> 00:02:08.810
Quindi, l'area successiva
dove le persone vengono gettate

00:02:08.810 --> 00:02:12.305
spento ha a che fare con il
ReactiveX e ReactiveUI,

00:02:12.305 --> 00:02:14.345
e dove sono quei punti di divisione.

00:02:14.345 --> 00:02:21.810
Così ReactiveX è
un concetto indipendente dalla piattaforma.

00:02:21.810 --> 00:02:25.760
Quindi il concetto Di ReactiveX

00:02:25.760 --> 00:02:28.940
è implementato in tutto
più quadri.

00:02:28.940 --> 00:02:35.390
Quindi c'è un cocco, un Java, RxJS.

00:02:35.390 --> 00:02:40.515
C'è tutta una fascia di lingue
che implementano i concetti.

00:02:40.515 --> 00:02:45.090
Quindi, ReactiveUI è il livello MVVM

00:02:45.090 --> 00:02:48.750
che aiuta a collegare ReactiveX
nella mVVM.

00:02:48.750 --> 00:02:52.905
Così, quando le persone sono
parlando di Reattivo,

00:02:52.905 --> 00:02:54.705
non stanno solo parlando
informazioni su ReactiveUI.

00:02:54.705 --> 00:02:55.820
Si tratta principalmente di

00:02:55.820 --> 00:02:59.090
programmazione reattiva funzionale e

00:02:59.090 --> 00:03:02.810
come basato osservabile
paradigmi di programmazione funzionano.

00:03:02.810 --> 00:03:05.870
Quindi l'aspetto ReactiveX è

00:03:05.870 --> 00:03:10.655
in gran parte ciò che questo discorso è
andando a girare intorno,

00:03:10.655 --> 00:03:15.245
che sarà un buon precursore
per il discorso di Michael più tardi.

00:03:15.245 --> 00:03:18.830
Allora perché mi ha esonerato?

00:03:18.830 --> 00:03:20.240
Aspettare. Probabilmente
forse non ce l'ho

00:03:20.240 --> 00:03:22.845
Evidenziato. Ecco fatto.

00:03:22.845 --> 00:03:29.300
Quindi cerchiamo di abbattere ciò che
stiamo davvero guardando qui.

00:03:29.300 --> 00:03:32.420
Quindi parliamo di
eventi molto veloce.

00:03:32.420 --> 00:03:35.570
Quindi, come si fa a sottoscrivere
Eventi? È tutto piuttosto semplice.

00:03:35.570 --> 00:03:37.945
Abbiamo visto tutti questo codice prima.

00:03:37.945 --> 00:03:41.190
Ecco. Piuttosto eccitante, giusto?

00:03:41.190 --> 00:03:46.085
In modo così efficace, avete
l'editore a sinistra.

00:03:46.085 --> 00:03:48.260
Hai i tuoi eventi
e poi hai

00:03:48.260 --> 00:03:50.990
il vostro osservatore sulla destra lì.

00:03:50.990 --> 00:03:57.230
Quindi, è un evento di base
modello di notifica,

00:03:57.230 --> 00:03:58.760
il vostro modello di osservatore di base.

00:03:58.760 --> 00:04:02.030
Quindi questa era la sintassi in C .

00:04:02.030 --> 00:04:04.190
In effetti, la parte superiore
si fa la stessa cosa

00:04:04.190 --> 00:04:06.395
come il fondo, ma lo zucchero sintattico.

00:04:06.395 --> 00:04:10.725
Quindi cerchiamo di abbattere ciò che un evento è.

00:04:10.725 --> 00:04:14.005
Quindi un evento è essenzialmente,

00:04:14.005 --> 00:04:21.095
si tratta di una serie di cose individuali
che si verificano ai dati di produzione.

00:04:21.095 --> 00:04:25.260
Quindi, se sto scrivendo il mio nome,

00:04:25.990 --> 00:04:29.930
Io tipo S, c'è
un evento, h ed evento,

00:04:29.930 --> 00:04:33.635
a e evento, penso che si vede
dove tutto questo sta andando,

00:04:33.635 --> 00:04:39.080
e la rappresentazione
di questi dati è qui.

00:04:39.080 --> 00:04:41.990
Quindi questo è l'insieme di dati che hanno

00:04:41.990 --> 00:04:46.325
si è verificato in base a tali eventi.

00:04:46.325 --> 00:04:49.220
Ecco, questo è il tuo evento.

00:04:49.220 --> 00:04:51.455
Quindi niente di troppo strabiliante
a questo punto.

00:04:51.455 --> 00:04:55.340
Quindi i passi per interrompere l'osservazione di un evento.

00:04:55.340 --> 00:04:58.000
Quindi, come si fa a smettere
osservare un evento?

00:04:58.000 --> 00:05:00.600
Abbiamo tutti inosservato
eventi frontali, giusto?

00:05:00.600 --> 00:05:01.760
Come tutti abbiamo detto: "Ehi, non posso

00:05:01.760 --> 00:05:03.620
più cura di ciò che
questa cosa accade.

00:05:03.620 --> 00:05:08.960
Quindi di solito, il processo
di capire come

00:05:08.960 --> 00:05:11.720
per annullare la sottoscrizione dell'evento

00:05:11.720 --> 00:05:15.155
con il cliente che si lamenta
che l'app sia lenta.

00:05:15.155 --> 00:05:19.070
Così i file dei clienti
un problema e dice: "Ehi,

00:05:19.070 --> 00:05:21.840
la mia app rallenta dopo l'utilizzo.

00:05:22.670 --> 00:05:24.690
Cosa sta succedendo?

00:05:24.690 --> 00:05:27.075
Più lo uso,
non funziona."

00:05:27.075 --> 00:05:30.550
Quindi, prima, non ci credi.

00:05:31.400 --> 00:05:35.090
Pensi che abbiano
installato qualcosa di simile

00:05:35.090 --> 00:05:37.730
Dilbert screensaver che sta prendendo

00:05:37.730 --> 00:05:39.980
l'intera finestra del browser
o qualcosa del genere.

00:05:39.980 --> 00:05:42.290
Perché quando si inizia
l'applicazione e

00:05:42.290 --> 00:05:44.795
si utilizza per
circa 15 secondi, è veloce.

00:05:44.795 --> 00:05:46.895
Tutto funziona alla grande.
È reattivo.

00:05:46.895 --> 00:05:51.670
Hai capito che è perfetto.

00:05:51.670 --> 00:05:54.435
Allora, tu dici: "Tutti
va bene. Credo di credere a loro.

00:05:54.435 --> 00:05:58.530
Quindi, a questo punto, si polvere
dal cappello di debug,

00:05:58.530 --> 00:06:01.110
rileggere attraverso tutti i
test e blog su come

00:06:01.110 --> 00:06:04.185
per analizzare gli stack frame,

00:06:04.185 --> 00:06:06.675
e si inizia a tirare tutto dentro

00:06:06.675 --> 00:06:08.145
Si ottiene lo stack DOMs.

00:06:08.145 --> 00:06:10.925
Si guarda a quanto tempo
gli oggetti sono vivi.

00:06:10.925 --> 00:06:13.055
Lo fai più e più volte.

00:06:13.055 --> 00:06:15.740
Finalmente, stai scendendo.

00:06:15.740 --> 00:06:18.290
C'è un sacco di fissare
frecce che puntano alle cose,

00:06:18.290 --> 00:06:19.940
e chiedersi quali oggetti contano,

00:06:19.940 --> 00:06:22.280
e sottraendo questo
da questo fino a quando si

00:06:22.280 --> 00:06:23.900
finalmente vedere che ci

00:06:23.900 --> 00:06:25.595
era che una riga di codice o
ti sei dimenticato di scriverlo.

00:06:25.595 --> 00:06:27.990
"Oh, amico."
Poi, all'improvviso,

00:06:27.990 --> 00:06:30.195
tutto inizia a correre super veloce.

00:06:30.195 --> 00:06:33.699
Quindi sì, voglio dire, fondamentalmente,

00:06:35.210 --> 00:06:38.280
abbonarsi e annullare l'iscrizione.

00:06:38.280 --> 00:06:43.980
Questa è la semantica.

00:06:43.980 --> 00:06:48.345
Ma la semantica, è
un po 'nodoso mi sento come.

00:06:48.345 --> 00:06:52.655
Perché uno, si deve
ricordatevi di fare due cose.

00:06:52.655 --> 00:06:55.130
Ogni volta che devo ricordare
per fare più di una cosa,

00:06:55.130 --> 00:06:57.850
si sta andando a fallire
di solito nella programmazione.

00:06:57.850 --> 00:07:00.695
Inoltre, è necessario mantenere
i vostri riferimenti a tutto.

00:07:00.695 --> 00:07:04.040
Quindi, per fare l'importanza
di quel secondo,

00:07:04.040 --> 00:07:05.210
avete bisogno di tutto ciò che è in

00:07:05.210 --> 00:07:08.125
il tuo primo a fare
tutto nel secondo,

00:07:08.125 --> 00:07:11.930
come si deve
mantenere queste idee.

00:07:11.930 --> 00:07:16.725
Quindi, in generale la gestione degli eventi
è solo, è disordinato.

00:07:16.725 --> 00:07:20.015
Non è il tipo più pulito
dell'operazione.

00:07:20.015 --> 00:07:21.290
Voglio dire, diciamo,

00:07:21.290 --> 00:07:26.600
ti interessa solo
un singolo evento, ad esempio,

00:07:26.600 --> 00:07:28.465
Come se tutti abbiamo scritto questo codice,

00:07:28.465 --> 00:07:31.340
dove se si vuole
annullare l'iscrizione a qualcosa di simile

00:07:31.340 --> 00:07:35.600
si voleva solo licenziare uno.

00:07:35.600 --> 00:07:38.915
Quindi diciamo, come una pagina che appare
o qualcosa di quella natura,

00:07:38.915 --> 00:07:42.140
quindi devi avere
il riferimento in alto

00:07:42.140 --> 00:07:45.830
in modo che la chiusura
all'interno ha accesso ad esso,

00:07:45.830 --> 00:07:47.975
quindi si assegna il gestore,

00:07:47.975 --> 00:07:50.255
e poi si fa
il gestore alla fine.

00:07:50.255 --> 00:07:55.280
Quindi c'è questa cerimonia successiva

00:07:55.280 --> 00:07:59.150
che viene dal
set di operazioni.

00:07:59.150 --> 00:08:03.050
Quindi questo sembra familiare. presente semplice di "be" alla terza persona singolare
tutti hanno scritto questo codice prima?

00:08:03.050 --> 00:08:05.790
sì? Va bene.

00:08:06.930 --> 00:08:12.655
Così ed eccomi ancora
parlando di eventi.

00:08:12.655 --> 00:08:14.860
Questo è ciò che io chiamo il mio
IObservable Infomercial.

00:08:14.860 --> 00:08:16.360
Dove fai qualcosa
pazzo e tu sei come,

00:08:16.360 --> 00:08:17.680
"Oh mio Dio, è così terribile."

00:08:17.680 --> 00:08:22.135
Non è poi così male. Ma qui
Sto indicando tutta la roba.

00:08:22.135 --> 00:08:24.115
Questa non è Xamarin Forms,

00:08:24.115 --> 00:08:26.725
quando si esegue il collegamento a un evento.

00:08:26.725 --> 00:08:29.485
Così si collega all'evento,

00:08:29.485 --> 00:08:32.425
devi trovare ok,
dove sono i miei aspetti di smaltimento?

00:08:32.425 --> 00:08:33.835
Ok, è quaggiù.

00:08:33.835 --> 00:08:37.330
Devo assicurarmi di
eliminare gli eventi e

00:08:37.330 --> 00:08:41.350
tutta questa roba è in disparati
posizioni nell'intero file.

00:08:41.350 --> 00:08:42.730
Queste sono tutte queste cose.

00:08:42.730 --> 00:08:44.290
Questa cerimonia devi fare

00:08:44.290 --> 00:08:46.240
con tutti questi eventi
sistemi di gestione.

00:08:46.240 --> 00:08:48.790
Guarda lassù, si
devono sottoscriverlo.

00:08:48.790 --> 00:08:51.385
Allora hai il tuo addestratore quaggiù.

00:08:51.385 --> 00:08:52.810
Hai a che fare con i dati in

00:08:52.810 --> 00:08:55.180
un punto separato e
poi si piega qui.

00:08:55.180 --> 00:08:59.635
E 'questo molto
un'esperienza disconnessa.

00:08:59.635 --> 00:09:01.240
Così qui ho anche digitato
le cose sbagliate,

00:09:01.240 --> 00:09:03.625
Sono così agitato a quanto sia difficile.

00:09:03.625 --> 00:09:07.720
Ma sì. Così ho avuto l'infomercial,
Dov'è andata la soda?

00:09:07.720 --> 00:09:13.225
Ecco, questo è il punto.

00:09:13.225 --> 00:09:18.175
Quindi gli eventi sono questi singolari
punti dati sincroni.

00:09:18.175 --> 00:09:20.650
Così si ottiene un eventi di modifica del testo

00:09:20.650 --> 00:09:22.690
e poi tutto quello che hai è
che l'evento di modifica del testo.

00:09:22.690 --> 00:09:24.460
Hai solo quella lettera.
Hai solo quella lettera

00:09:24.460 --> 00:09:27.195
S che devi affrontare.

00:09:27.195 --> 00:09:29.145
Ma cosa succede se si vuole
per fare di più con questo?

00:09:29.145 --> 00:09:31.200
Cosa succede se, perché ogni volta che
avete un evento,

00:09:31.200 --> 00:09:33.840
ti importa molto raramente
su un evento.

00:09:33.840 --> 00:09:36.680
Ti preoccupi dei dati
set di eventi.

00:09:36.680 --> 00:09:37.870
Ti importa di tutto ciò che è

00:09:37.870 --> 00:09:40.510
nel corso del periodo di tempo.

00:09:40.510 --> 00:09:43.750
Quindi cosa succede se si vuole fare
qualcosa di molto eccitante.

00:09:43.750 --> 00:09:45.220
Quindi cosa succede se si vuole dire,

00:09:45.220 --> 00:09:47.590
saltare i primi cinque eventi e

00:09:47.590 --> 00:09:50.050
allora ci interessano solo i prossimi quattro,

00:09:50.050 --> 00:09:52.015
allora vuoi rimbalzare gli eventi,

00:09:52.015 --> 00:09:56.139
quindi se stanno digitando super-veloce
solo aspettare due secondi,

00:09:56.139 --> 00:09:57.610
allora diciamo che si desidera filtrare

00:09:57.610 --> 00:09:59.215
tutti gli eventi che sono blu fiore di mais

00:09:59.215 --> 00:10:02.545
solo perché è un colore orribile
forse, non lo so.

00:10:02.545 --> 00:10:05.110
Poi si desidera

00:10:05.110 --> 00:10:07.120
dare il via alla richiesta web
e poi ricominciano da capo,

00:10:07.120 --> 00:10:08.860
quindi vuoi buttarlo via.

00:10:08.860 --> 00:10:12.220
Come questo tipo di modello è

00:10:12.220 --> 00:10:16.900
molto comune per quanto riguarda
gestione degli eventi,

00:10:16.900 --> 00:10:22.630
specialmente nei quadri MVVM e
elementi che sono più basati sull'interfaccia utente.

00:10:22.630 --> 00:10:25.420
Devi sempre reagire

00:10:25.420 --> 00:10:29.830
contro i punti dati in arrivo
con la perdita della connettività.

00:10:29.830 --> 00:10:31.240
Quindi, come se
la connettività ottiene

00:10:31.240 --> 00:10:33.460
perso alle richieste web a puntare?

00:10:33.460 --> 00:10:34.870
Come si interrompe

00:10:34.870 --> 00:10:39.745
che la richiesta web una volta
la connettività è persa?

00:10:39.745 --> 00:10:48.460
Come si fa a farlo in modo affidabile
facile da gestire.

00:10:48.460 --> 00:10:50.680
Quindi tutti questi concetti hanno

00:10:50.680 --> 00:10:58.060
versioni molto chiare dei verbi
che li ha mappati in reattivo.

00:10:58.060 --> 00:10:59.830
Quindi questi sono tutti
cose reali è possibile

00:10:59.830 --> 00:11:02.590
utilizzare in reattivo per articolare

00:11:02.590 --> 00:11:07.795
tutti questi tentativi sui tuoi dati,

00:11:07.795 --> 00:11:09.880
flusso di eventi nel corso dell'anno.

00:11:09.880 --> 00:11:13.720
Va bene. Quindi cos'altro
possiamo fare con gli eventi?

00:11:13.720 --> 00:11:19.010
Non così tanto.
I modelli di base molto semplici.

00:11:19.260 --> 00:11:23.725
Ecco, questo è il mio tear-down di eventi.

00:11:23.725 --> 00:11:26.110
Quindi, a questo punto, se
non hai davvero usato

00:11:26.110 --> 00:11:28.450
reattivo sei probabilmente come,
"Oh, sono stato così terribile.

00:11:28.450 --> 00:11:31.600
Ho fatto questo sbagliato il
tutto il tempo", e si sta avendo

00:11:31.600 --> 00:11:33.610
una crisi esistenziale su

00:11:33.610 --> 00:11:37.970
tutti i problemi che non hai
so che hai avuto che ora avete.

00:11:39.900 --> 00:11:45.580
Quindi traduciamo questo
verso Observables.

00:11:45.580 --> 00:11:48.370
Così IObservable è stato
in giro per un po' .

00:11:48.370 --> 00:11:49.660
E 'essenzialmente proprio come

00:11:49.660 --> 00:11:52.855
un modello di sottoscrizione di pubblicazione

00:11:52.855 --> 00:11:55.900
che è all'interno del nucleo
quadro of.Net e

00:11:55.900 --> 00:11:59.005
allora ReactiveX è più di

00:11:59.005 --> 00:12:04.465
un'espressione di come interagire
con quegli Observables.

00:12:04.465 --> 00:12:11.245
Quindi cerchiamo di abbattere ciò che
un Observable è qui.

00:12:11.245 --> 00:12:15.020
Quindi è essenzialmente
un modello Observer.

00:12:18.690 --> 00:12:21.790
Fondamentalmente, è
la stessa cosa di un evento.

00:12:21.790 --> 00:12:26.000
Un evento è efficace
un modello di osservatore.

00:12:27.420 --> 00:12:30.775
Quindi hai il tuo evento qui,

00:12:30.775 --> 00:12:34.449
il gestore e l'editore

00:12:34.449 --> 00:12:37.870
e poi questo è analogo
a questo qui.

00:12:37.870 --> 00:12:42.865
Così avete il vostro osservabile
che sta guardando,

00:12:42.865 --> 00:12:45.070
la sua fare la stessa cosa.

00:12:45.070 --> 00:12:47.980
Quindi hai la stessa idea.

00:12:47.980 --> 00:12:51.220
In effetti, si può fare l'esatto
stessa cosa con entrambi a

00:12:51.220 --> 00:12:54.925
lo strato di base e
ottenere i punti dati.

00:12:54.925 --> 00:12:56.650
Ma la cosa eccitante ora,

00:12:56.650 --> 00:12:58.285
quindi è qui che i punti emozionanti

00:12:58.285 --> 00:13:00.620
di tutto entra in gioco.

00:13:03.690 --> 00:13:07.540
Con un evento, non
davvero avere qualcosa.

00:13:07.540 --> 00:13:09.385
Hai solo un evento.

00:13:09.385 --> 00:13:11.770
Ma ora con un osservabile,

00:13:11.770 --> 00:13:13.510
si dispone di una rappresentazione
di quell'evento.

00:13:13.510 --> 00:13:17.095
In realtà hai come un oggetto dati
con cui puoi fare le cose.

00:13:17.095 --> 00:13:22.645
Quindi è la differenza
tra avere un elemento da

00:13:22.645 --> 00:13:25.360
un elenco invece di diverso da

00:13:25.360 --> 00:13:28.675
avendo detto l'intera lista
che ora è possibile operare su.

00:13:28.675 --> 00:13:32.140
Ecco dove il vostro
di differenza entrano in gioco.

00:13:32.140 --> 00:13:35.590
Così si può pensare al
osservabile molto

00:13:35.590 --> 00:13:39.550
come modello iteratore.

00:13:39.550 --> 00:13:42.340
Quindi questo è preso da reactivex. Io

00:13:42.340 --> 00:13:44.485
che è una delle principali fonti,

00:13:44.485 --> 00:13:45.520
che è davvero una buona fonte.

00:13:45.520 --> 00:13:48.100
Ha una ripartizione di
tutti i vostri operatori e tutto il resto.

00:13:48.100 --> 00:13:49.930
Così ho un link ad esso ci
in fondo per voi.

00:13:49.930 --> 00:13:56.605
sì è effettivamente mappatura

00:13:56.605 --> 00:14:02.170
la tua idea osservabile di

00:14:02.170 --> 00:14:03.925
le stesse cose che puoi
fare con un iteratore.

00:14:03.925 --> 00:14:05.635
C'è quasi un perfetto

00:14:05.635 --> 00:14:08.560
confronti uno a uno
lì, quando si scorre.

00:14:08.560 --> 00:14:11.605
Quindi un iteratore è come IEnumerator.

00:14:11.605 --> 00:14:13.945
Questo è l'equivalente.

00:14:13.945 --> 00:14:18.085
IEnumerator è ciò che è equivalente
a IObservable, fondamentalmente.

00:14:18.085 --> 00:14:19.750
Quindi tutto quello che puoi
fare a un IEnumerator,

00:14:19.750 --> 00:14:21.355
si può fare a un IObservable.

00:14:21.355 --> 00:14:23.410
Così che era come ricordare
quando Link è arrivato per la prima volta

00:14:23.410 --> 00:14:25.990
fuori e tutti erano
super eccitato

00:14:25.990 --> 00:14:28.225
Link come Link su oggetti e

00:14:28.225 --> 00:14:31.510
Link a SQL e poi sono stati
meno entusiasti di Link to SQL,

00:14:31.510 --> 00:14:33.800
ma Link era così eccitante.

00:14:36.960 --> 00:14:41.260
Così efficacemente avete il vostro
dati recuperati che è il prossimo, onNext.

00:14:41.260 --> 00:14:44.650
Così come ogni dato
punti vengono attraverso.

00:14:44.650 --> 00:14:47.920
Ecco dove si ferma fino a dove

00:14:47.920 --> 00:14:52.030
Gli osservabili diventano più
emozionante che i vostri eventi.

00:14:52.030 --> 00:14:54.550
Così si ottiene queste altre cose.

00:14:54.550 --> 00:14:56.875
Così si ottiene un'aria per esempio.

00:14:56.875 --> 00:15:02.770
Se il tuo evento che stai
osservando manifesta un'eccezione,

00:15:02.770 --> 00:15:05.800
si può affrontare che come
parte dell'osservabile.

00:15:05.800 --> 00:15:09.340
Quindi, come parte del flusso di dati di
l'operazione, è possibile indicare,

00:15:09.340 --> 00:15:12.970
hey c'è questo evento
tramite un'eccezione.

00:15:12.970 --> 00:15:14.515
Quindi, per esempio, una richiesta web.

00:15:14.515 --> 00:15:16.990
Se si verifica una richiesta Web

00:15:16.990 --> 00:15:20.020
genera un'eccezione perché

00:15:20.020 --> 00:15:22.165
Internet va giù o
qualcosa di simile,

00:15:22.165 --> 00:15:24.850
allora si può effettivamente prendere che

00:15:24.850 --> 00:15:28.645
e affrontare questo
all'interno di tale costrutto.

00:15:28.645 --> 00:15:29.920
Così rende il codice un sacco

00:15:29.920 --> 00:15:35.695
più robusto e poi si
anche ottenere questa idea di

00:15:35.695 --> 00:15:39.760
completamento in cui è possibile sparare se

00:15:39.760 --> 00:15:43.345
qualcuno ha indicato che

00:15:43.345 --> 00:15:45.790
non si preoccupano più
sui punti dati,

00:15:45.790 --> 00:15:47.725
si può quindi agire su questo.

00:15:47.725 --> 00:15:50.590
Tutte queste cose
diventare caratteristiche di

00:15:50.590 --> 00:15:54.070
come interagisci con i tuoi dati.

00:15:54.070 --> 00:16:01.760
Quindi, ecco un po 'di più
punti di confronto.

00:16:06.120 --> 00:16:09.070
Quindi questo è anche preso da ReactiveX.

00:16:09.070 --> 00:16:13.030
Come potete vedere qui, avete il vostro
È più piacevole il tuo lasso di tempo,

00:16:13.030 --> 00:16:14.890
in modo che è come il vostro IEnumerator e

00:16:14.890 --> 00:16:16.860
hai ragione che
è il tuo IObservable.

00:16:16.860 --> 00:16:19.150
Così uno è ottenere i dati
dalla memoria locale,

00:16:19.150 --> 00:16:20.210
in modo che sta per essere forse come un

00:16:20.210 --> 00:16:21.890
operazione sincrona in cui si

00:16:21.890 --> 00:16:23.870
far capire i tuoi dati in

00:16:23.870 --> 00:16:26.240
la parte superiore e hai ragione
uno è dalla rete,

00:16:26.240 --> 00:16:29.580
potrebbe essere un feed di dati più lento.

00:16:29.580 --> 00:16:32.915
Così lì, si può vedere
si ottiene queste stesse idee

00:16:32.915 --> 00:16:37.350
sui vostri flussi di eventi che
è solo, è super-potente.

00:16:37.870 --> 00:16:42.940
Roba da un lato. Va bene.

00:16:42.940 --> 00:16:45.450
Analizziamo il modo in cui

00:16:45.450 --> 00:16:48.610
elementi costitutivi di
i tuoi IObservables un po 'qui.

00:16:50.010 --> 00:16:54.250
Quindi questa è l'idea di base di
come si costruisce IObservable.

00:16:54.250 --> 00:16:57.205
Quindi, come vedete in
quel primo passo lì,

00:16:57.205 --> 00:17:01.940
si vede l'iscrizione familiare
e annullare l'iscrizione,

00:17:03.840 --> 00:17:07.450
non è così eccitante,
è solo di passaggio attraverso

00:17:07.450 --> 00:17:10.390
diverse funzioni per l'osservatore,

00:17:10.390 --> 00:17:11.830
così l'osservatore sa come affrontare

00:17:11.830 --> 00:17:14.185
con abbonamenti e annullamenti di iscrizioni,

00:17:14.185 --> 00:17:18.250
in modo che possa incontainerizzare che
comportamento all'interno di IObservable.

00:17:18.250 --> 00:17:26.185
Quindi, ecco la comparativa
versioni di questi,

00:17:26.185 --> 00:17:29.515
di ciò che rappresentano.

00:17:29.515 --> 00:17:34.690
Quindi sottoscrivere è in modo efficace
invocando quel ragazzo di punta,

00:17:34.690 --> 00:17:37.840
il più in alto cliccato
e dicendo: "Ok,

00:17:37.840 --> 00:17:40.090
ora mi preoccupo per i miei eventi," e poi

00:17:40.090 --> 00:17:43.000
quello in basso ci
sta disponendo,

00:17:43.000 --> 00:17:45.715
che è poi l'annullamento dell'iscrizione.

00:17:45.715 --> 00:17:48.730
È qui che inizia
per diventare davvero potente,

00:17:48.730 --> 00:17:54.535
perché avete
tutta questa rappresentazione

00:17:54.535 --> 00:17:58.210
è incapsulato in uno schema familiare.

00:17:58.210 --> 00:18:01.810
Quindi hai IDisposable
che tutti abbiamo usato,

00:18:01.810 --> 00:18:10.080
e abbiamo strutture di dati logici

00:18:10.080 --> 00:18:11.310
e modi che possiamo usare

00:18:11.310 --> 00:18:14.760
quelli più efficacemente di
basta dire uniscrivimento.

00:18:14.760 --> 00:18:18.700
Così alcuni davvero cool
modi in cui puoi farlo,

00:18:18.700 --> 00:18:20.680
si può facilmente gestire
questi tempi di vita.

00:18:20.680 --> 00:18:25.359
Quindi ricordate prima dove avete
per assicurarsi di annullare l'iscrizione,

00:18:25.359 --> 00:18:28.600
così come in Xamarin Forms per esempio,

00:18:28.600 --> 00:18:32.590
se si sta cambiando un elemento
o se qualcosa di nuovo viene

00:18:32.590 --> 00:18:34.210
in quanto si desidera iscriversi a

00:18:34.210 --> 00:18:36.325
e non ti importa
la cosa vecchia più,

00:18:36.325 --> 00:18:40.000
devi fare questa cosa in cui
annulli l'iscrizione al vecchio,

00:18:40.000 --> 00:18:41.290
abbonarsi al nuovo,

00:18:41.290 --> 00:18:44.920
poi anche il vostro punto smaltimento hanno

00:18:44.920 --> 00:18:48.955
per assicurarsi che si sta annullando l'iscrizione
da quegli eventi pure.

00:18:48.955 --> 00:18:50.650
Ecco cosa è pulito però,

00:18:50.650 --> 00:18:57.070
è che l'intero evento
sistema di gestione delle osservazioni

00:18:57.070 --> 00:19:00.055
può essere articolato
attraverso gli usa e getta.

00:19:00.055 --> 00:19:02.740
Agiamo in tal modo e molto
di queste cose qui

00:19:02.740 --> 00:19:05.215
Vorrei che avrebbero solo tirare
in the.Net Framework,

00:19:05.215 --> 00:19:08.290
ma per ora, in

00:19:08.290 --> 00:19:11.440
ReactiveX hai queste cose
come CompositeDisposable.

00:19:11.440 --> 00:19:13.450
Quindi l'idea c'è
è possibile aggregare

00:19:13.450 --> 00:19:17.035
tutti i vostri usa e getta in
una singola struttura di dati,

00:19:17.035 --> 00:19:20.260
e poi quella struttura di dati ora,

00:19:20.260 --> 00:19:22.225
si può solo smaltire una volta,

00:19:22.225 --> 00:19:26.125
una volta che la vita di
la classe che li contiene non c'è più,

00:19:26.125 --> 00:19:28.540
e ora tutto il tuo evento
gestione è curata.

00:19:28.540 --> 00:19:33.310
Così si può collegare il vostro
Sottoscrizioni PropertyChanged lì,

00:19:33.310 --> 00:19:37.570
gli abbonamenti TextChanged,
e poi basta smaltirlo.

00:19:37.570 --> 00:19:38.650
Quindi è pulito perché si sta ottenendo

00:19:38.650 --> 00:19:44.200
questi concetti di oggetti che
puoi applicare ai tuoi eventi,

00:19:44.200 --> 00:19:48.740
quindi è bello, mi piace.

00:19:51.900 --> 00:19:55.030
Per esempio, come se fossi
parlando prima,

00:19:55.030 --> 00:19:57.430
dove si dispone di un'istanza

00:19:57.430 --> 00:19:59.725
dove si dispone di un vecchio elemento
a cui sei iscritto,

00:19:59.725 --> 00:20:01.000
Voglio dire, arriva un nuovo elemento

00:20:01.000 --> 00:20:04.690
in modo che non ti interessa
il vecchio più.

00:20:04.690 --> 00:20:06.310
Quindi ha come questi concetti interessanti

00:20:06.310 --> 00:20:08.110
qui con come una disposizione seriale,

00:20:08.110 --> 00:20:09.910
dove tutto ciò che si
assegnare a che sarà

00:20:09.910 --> 00:20:12.250
smaltire automaticamente
della cosa prima di esso.

00:20:12.250 --> 00:20:14.980
Quindi in queste idee qui,

00:20:14.980 --> 00:20:16.900
non c'è bisogno di

00:20:16.900 --> 00:20:19.690
annullare l'iscrizione per ciò che è venuto in
lì, che è davvero pulito.

00:20:19.690 --> 00:20:23.530
Ma sai che questo è
il nuovo caldo che ti interessa,

00:20:23.530 --> 00:20:25.390
e poi una volta che arriva,

00:20:25.390 --> 00:20:28.735
basta sbarazzarsi di
tutto ciò che c'era prima,

00:20:28.735 --> 00:20:30.370
in modo che consente di impostare

00:20:30.370 --> 00:20:36.470
queste espressioni davvero cool
di quello che vuoi fare.

00:20:37.320 --> 00:20:41.770
Perché un sacco di roba con
Reattivo che è davvero bello,

00:20:41.770 --> 00:20:47.560
è avere tutti i vostri intenti
in un'unica posizione.

00:20:47.560 --> 00:20:51.050
La gestione degli eventi è
molto basato su callback,

00:20:52.080 --> 00:20:56.320
non si ottiene in come cattivi stili
come un inferno di richiamata totale,

00:20:56.320 --> 00:20:58.645
ma è ancora gentile
della stessa cosa.

00:20:58.645 --> 00:21:01.330
È la gestione dei callback
e poi interagire

00:21:01.330 --> 00:21:03.760
tutti questi callback diversi
scenari in cui si dispone di

00:21:03.760 --> 00:21:06.665
la stessa cosa con come si
gestire la durata di esso.

00:21:06.665 --> 00:21:13.470
Ma qualcuno qui ha fatto
Roba Xamarin Forms?

00:21:13.470 --> 00:21:17.050
Sto solo mappando
modelli logici qui.

00:21:17.050 --> 00:21:20.455
Così avete questa idea ora dove

00:21:20.455 --> 00:21:25.690
il modo in cui è possibile

00:21:25.690 --> 00:21:27.250
gestire l'intero ciclo di vita

00:21:27.250 --> 00:21:30.635
qualcosa è giusto
lì in quella parte centrale,

00:21:30.635 --> 00:21:33.840
e questo è tutto quello che dovete fare.

00:21:33.840 --> 00:21:36.315
Una volta che è impostato lì,

00:21:36.315 --> 00:21:40.635
ora ogni volta che si entra e
si ha un cambiamento di elemento,

00:21:40.635 --> 00:21:42.650
e ti interessa solo
sul nuovo elemento,

00:21:42.650 --> 00:21:47.230
assegnazione di una nuova causa usa e getta
il precedente da smaltire,

00:21:47.230 --> 00:21:49.990
così ora tutti i tuoi eventi
sono totalmente scollegati,

00:21:49.990 --> 00:21:52.645
e poi ora si inizia
cablaggio i nuovi.

00:21:52.645 --> 00:21:53.860
Poi nel vostro disposto,

00:21:53.860 --> 00:21:56.260
hai solo un singolo
smaltire seriale che è

00:21:56.260 --> 00:22:01.750
la risorsa gestita a livello di classe
che si sta smaltindo.

00:22:01.750 --> 00:22:06.880
Così ora non c'è

00:22:06.880 --> 00:22:10.480
questa complessità della gestione come
per quanto riguarda la vostra gestione anticipata.

00:22:10.480 --> 00:22:13.300
Quindi questo in realtà era
la prima cosa che mi ha portato in

00:22:13.300 --> 00:22:17.630
La programmazione reattiva è stata
la gestione dello usa e getta,

00:22:18.900 --> 00:22:22.150
Penso che sia stato come un anno prima
Avevo anche usato qualcos'altro.

00:22:22.150 --> 00:22:25.540
Solo perché avevo un Silverlight
applicazione che stava avendo

00:22:25.540 --> 00:22:30.775
alcuni problemi di abbonamento e
poi mi è capitato su questa roba,

00:22:30.775 --> 00:22:32.815
quindi questa roba è cool,

00:22:32.815 --> 00:22:34.870
gli usa e getta mi rendono super felice.

00:22:34.870 --> 00:22:37.390
Quindi questi sono ancora mappando alcuni dei

00:22:37.390 --> 00:22:40.120
queste idee che sono
davvero pulito, così come qui,

00:22:40.120 --> 00:22:42.700
ricordare prima quando si
voleva iscriversi solo a

00:22:42.700 --> 00:22:45.445
che un evento e solo
voleva vederlo una volta?

00:22:45.445 --> 00:22:48.640
Con Reactive, si può fare

00:22:48.640 --> 00:22:52.045
che l'intero concetto qui
con questa espressione.

00:22:52.045 --> 00:22:54.160
Quindi tutto questo dice:

00:22:54.160 --> 00:22:58.839
"Voglio solo un valore da
questa proprietà modificata,

00:22:58.839 --> 00:23:02.680
e poi a quel punto ho
voglio che tu sbarazzessi di esso.

00:23:02.680 --> 00:23:05.335
Quindi voglio dire che è impressionante proprio lì,

00:23:05.335 --> 00:23:07.555
Prendine uno e poi passa,

00:23:07.555 --> 00:23:10.180
che è un po 'difficile da
capire, ma quelli sono

00:23:10.180 --> 00:23:13.270
motivi sufficienti
per usarlo per sempre,

00:23:13.270 --> 00:23:15.340
è bello, mi piace.

00:23:15.340 --> 00:23:22.210
Ecco, questa è la ripartizione di
come funzionano le operazioni.

00:23:22.210 --> 00:23:31.670
Così ho un paio di demo di
realizzando questo nel codice un po 'di più,

00:23:33.360 --> 00:23:39.970
ma volevo dare un concetto
prep anche a voi,

00:23:39.970 --> 00:23:45.700
ad alcuni dei tipi di Reactive
strutture che stiamo usando,

00:23:45.700 --> 00:23:47.980
solo così ha un po 'più di senso.

00:23:47.980 --> 00:23:50.500
Quindi uno dei modi in cui descrivi le cose

00:23:50.500 --> 00:23:53.185
con Reactive è da
utilizzando diagrammi di marmo,

00:23:53.185 --> 00:23:55.075
quindi ci sono queste idee di vedere

00:23:55.075 --> 00:24:01.405
l'input e l'output.

00:24:01.405 --> 00:24:03.760
Quindi i primi due qui,

00:24:03.760 --> 00:24:10.285
questo è il volgare per
informazioni più reattive,

00:24:10.285 --> 00:24:14.800
così ogni volta che si vede
Operatori reattivi descritti,

00:24:14.800 --> 00:24:16.330
sono sempre descritti
in questo formato.

00:24:16.330 --> 00:24:19.810
Quindi l'idea qui è che
le due cose principali sono flussi di dati,

00:24:19.810 --> 00:24:23.480
e poi quello in basso è
ciò che vede il tuo abbonato.

00:24:24.420 --> 00:24:27.519
L'unione sarebbe due sottoscrittori,

00:24:27.519 --> 00:24:29.980
così come se si stavano sottoscrivendo
per pronunciare un evento TextChanged

00:24:29.980 --> 00:24:36.175
su una casella del nome utente e un
casella password per esempio,

00:24:36.175 --> 00:24:38.620
in qualsiasi momento uno dei
questi cambiamenti questo è

00:24:38.620 --> 00:24:40.690
l'aspetto dell'output.

00:24:40.690 --> 00:24:43.360
Quindi questi sono alcuni dei
gli operatori che ho usato nella demo,

00:24:43.360 --> 00:24:44.620
così volevo solo

00:24:44.620 --> 00:24:50.350
per assicurarsi che fossero
capito prima di andaci avanti.

00:24:50.350 --> 00:24:53.350
Quindi Filtro, questo è
fondamentalmente come un dove,

00:24:53.350 --> 00:24:57.460
così via il collegamento a IEnumerable,

00:24:57.460 --> 00:25:00.280
è proprio come un dove.

00:25:00.280 --> 00:25:02.260
Così efficacemente qualsiasi evento che viene

00:25:02.260 --> 00:25:05.810
attraverso, abbastanza semplice da capire.

00:25:05.850 --> 00:25:09.100
Debounce, quindi questo è
l'altra caratteristica davvero cool,

00:25:09.100 --> 00:25:11.395
quindi questo è la limitazione degli ingressi.

00:25:11.395 --> 00:25:13.570
Quindi in questo esempio quello che sono

00:25:13.570 --> 00:25:16.210
dimostrando qui è
che vogliono solo

00:25:16.210 --> 00:25:17.710
il valore più recente a venire

00:25:17.710 --> 00:25:21.025
fuori dopo un certo
impostare la quantità di tempo.

00:25:21.025 --> 00:25:25.840
Quindi potete vedere che c'è un ritardo
tra uno e cinque perché due,

00:25:25.840 --> 00:25:27.745
tre, e quattro sono

00:25:27.745 --> 00:25:30.280
accadendo così vicino tra loro
che cinque sta ora uscendo.

00:25:30.280 --> 00:25:33.910
Quindi questa è la quintessenza
esempio per le cose reattive,

00:25:33.910 --> 00:25:36.850
in modo che i casi in cui gli utenti sono

00:25:36.850 --> 00:25:39.400
facendo come la ricerca con

00:25:39.400 --> 00:25:42.305
Google durante la digitazione
nel loro completamento automatico,

00:25:42.305 --> 00:25:45.220
ma non si vuole come calcio
da una richiesta web ogni volta,

00:25:45.220 --> 00:25:48.640
in modo che sia effettivamente ciò che
questo sta dimostrando,

00:25:48.640 --> 00:25:50.305
di cui abbiamo un esempio.

00:25:50.305 --> 00:25:56.640
Poi TakeUntil è
l'ultimo operatore che uso,

00:25:56.640 --> 00:25:58.110
quindi TakeUntil è davvero pulito,

00:25:58.110 --> 00:26:01.170
perché questo è per esempio
come una richiesta web.

00:26:01.170 --> 00:26:04.605
Quindi diciamo che una richiesta web
sta inviando,

00:26:04.605 --> 00:26:07.210
e poi l'utente
ricomincia a digitare,

00:26:07.210 --> 00:26:09.880
o dicono annullare,

00:26:09.880 --> 00:26:11.560
come se non volessero
che succede più,

00:26:11.560 --> 00:26:16.360
quindi tutti quelli sono un altro
punti evento che è possibile mettere in atto,

00:26:16.360 --> 00:26:19.465
e a quel punto taglia
dal vostro flusso più.

00:26:19.465 --> 00:26:22.375
Quindi questo è come un davvero
modo semplice per dire tagliato,

00:26:22.375 --> 00:26:25.940
se non si desidera una richiesta Web
o qualcosa del genere per finire.

00:26:25.940 --> 00:26:32.400
Ecco, questa è la ripartizione
delle cose osservabili,

00:26:32.400 --> 00:26:35.470
quindi fammi passare,

00:26:36.080 --> 00:26:39.380
tenere su un secondo.

00:26:39.380 --> 00:26:52.660
Fantastico, vediamo.

00:26:53.540 --> 00:26:55.875
È troppo piccolo?

00:26:55.875 --> 00:26:57.610
>> sì.

00:26:58.710 --> 00:27:01.330
>> E 'cose che
fare quando ti rendi conto

00:27:01.330 --> 00:27:04.000
che non hai mai fatto
questi nelle demo prima,

00:27:04.000 --> 00:27:07.525
In realtà non sono mai aumentato
la sua dimensione del carattere su Obs Mac prima.

00:27:07.525 --> 00:27:16.300
Vediamo. Sto cercando di
fare le mie cose di Windows qui,

00:27:16.300 --> 00:27:20.540
ci andiamo, suppongo che sia tutto.

00:27:22.580 --> 00:27:26.610
Va bene stavo provando
i miei gesti sul pad.

00:27:26.610 --> 00:27:27.630
Ho fatto irtrapersi.

00:27:27.630 --> 00:27:28.650
Ho fatto due dita,

00:27:28.650 --> 00:27:32.670
L'ho fatto io. Non lo so.

00:27:32.670 --> 00:27:35.280
Non ci sono successo, credo.

00:27:35.280 --> 00:27:45.015
Così ci siamo. Ok, sì.

00:27:45.015 --> 00:27:46.740
Così, come si avvia windows
dove hai appena colpito

00:27:46.740 --> 00:27:48.615
controllo e dividerlo.

00:27:48.615 --> 00:27:51.910
Va bene in modo che tutti
può vedere che. Va bene?

00:27:52.070 --> 00:27:55.410
Quindi mi permetta di eseguire la demo reale

00:27:55.410 --> 00:27:59.895
veloce solo in modo da avere contesto
di quello che stiamo facendo qui.

00:27:59.895 --> 00:28:02.640
Quindi questo è una specie di
un'applicazione di base.

00:28:02.640 --> 00:28:08.355
È solo un'idea di logout di accesso.

00:28:08.355 --> 00:28:14.265
Sì, così sotto ho un set
di eventi che si stanno verificando,

00:28:14.265 --> 00:28:21.690
quindi questo è in modo efficace
flusso di dati degli osservabili.

00:28:21.690 --> 00:28:23.970
Quindi tutti gli eventi che sono
accadendo con gli osservabili.

00:28:23.970 --> 00:28:25.365
Quindi qui abbiamo il log in.

00:28:25.365 --> 00:28:27.240
Quindi questo è utente e password

00:28:27.240 --> 00:28:28.665
che avrei dovuto mettere
un registro dei segnaposto.

00:28:28.665 --> 00:28:34.095
Ma così l'idea qui si
può vedere se ho colpito una lettera.

00:28:34.095 --> 00:28:36.509
lì. Così colpire una lettera

00:28:36.509 --> 00:28:39.090
e a quel punto è
convalida dell'input.

00:28:39.090 --> 00:28:41.175
Ora si può vedere che
c'è tipo di questo ritardo.

00:28:41.175 --> 00:28:43.935
va bene? Quindi, se colpisco
"O" c'è un ritardo.

00:28:43.935 --> 00:28:46.170
Quindi l'idea alla base
che è che sei

00:28:46.170 --> 00:28:49.455
non- che è che debouncing
di cui stai parlando.

00:28:49.455 --> 00:28:54.945
Quindi, se digito il "Nome utente"
e la "Password".

00:28:54.945 --> 00:28:59.310
lì. Si può vedere che una volta
che la convalida avviene.

00:28:59.310 --> 00:29:01.710
Quindi questo è solo che ci sarà tipo di rottura
giù queste strutture una volta che ho

00:29:01.710 --> 00:29:04.275
entrare lì, ma questo è
l'idea dietro di esso.

00:29:04.275 --> 00:29:08.910
Così. sì. Così eccitante.

00:29:08.910 --> 00:29:11.955
Ora abbiamo una simulazione per il login.

00:29:11.955 --> 00:29:14.250
Quindi l'idea qui cliccherò su "Login".

00:29:14.250 --> 00:29:18.840
Si avvia una richiesta web e poi
a quel punto è possibile disconnettersi.

00:29:18.840 --> 00:29:21.870
Quindi e c'è una specie di

00:29:21.870 --> 00:29:26.415
ulteriore vediamo quante volte
ci vuole prima che questo si attivi.

00:29:26.415 --> 00:29:30.090
Quindi ho un randomizzatore
in là di casualmente

00:29:30.090 --> 00:29:35.415
generare errori. Eccolo.

00:29:35.415 --> 00:29:38.400
Bello. Così si può vedere qui che cosa

00:29:38.400 --> 00:29:41.775
accade è che io
cliccato su "Login".

00:29:41.775 --> 00:29:44.535
Ha generato un'eccezione.

00:29:44.535 --> 00:29:47.895
Così come l'eccezione richiesta Web.

00:29:47.895 --> 00:29:51.630
Poi ha detto va bene facciamo solo
riprovare a eseguire la richiesta Web.

00:29:51.630 --> 00:29:59.640
Poi a quel punto
poi mi ha registrato, giusto?

00:29:59.640 --> 00:30:02.655
Poi l'altro aspetto
di questo che sono io.

00:30:02.655 --> 00:30:05.070
Come diciamo che l'utente
desidera annullarlo.

00:30:05.070 --> 00:30:09.100
Quindi, se fanno clic su "Login"
possono fare clic su "Annulla".

00:30:09.350 --> 00:30:13.470
Ci si può vedere ora non è
l'elaborazione più lunga dei dati.

00:30:13.470 --> 00:30:16.035
va bene? Quindi perché

00:30:16.035 --> 00:30:18.885
c'è un tipo di operazione
di cancellarlo.

00:30:18.885 --> 00:30:23.805
Quindi questo è per demo.

00:30:23.805 --> 00:30:25.815
Sì, quindi questa è l'idea alla base.

00:30:25.815 --> 00:30:27.900
Questo è il codice.

00:30:27.900 --> 00:30:32.160
Sì, quindi l'idea

00:30:32.160 --> 00:30:34.965
dietro questo per tipo di
abbattere le strutture.

00:30:34.965 --> 00:30:37.935
Dal momento che abbiamo visto tutti un sacco
di queste cose è che

00:30:37.935 --> 00:30:41.340
questa è la componibilità
aspetto degli osservabili.

00:30:41.340 --> 00:30:43.890
L'aspetto della composizione
è che avete

00:30:43.890 --> 00:30:46.920
questa rappresentazione dei vostri eventi come

00:30:46.920 --> 00:30:50.730
questi singoli flussi di dati
che si può poi iniziare a

00:30:50.730 --> 00:30:55.845
intermix per articolare
il comportamento dell'applicazione.

00:30:55.845 --> 00:31:01.050
Quindi, se abbiamo l'applicazione che cosa sono
tutti i flussi di eventi su qui.

00:31:01.050 --> 00:31:03.360
I flussi di eventi sono
abbiamo la voce su

00:31:03.360 --> 00:31:07.065
la parte superiore abbiamo la voce
sui secondi campi.

00:31:07.065 --> 00:31:10.320
Come tipi di utenti abbiamo
fare clic sul pulsante Login.

00:31:10.320 --> 00:31:12.975
Abbiamo il pulsante Annulla fare clic su
e abbiamo come la Richiesta Web.

00:31:12.975 --> 00:31:17.205
Quindi abbiamo effettivamente
cinque eventi diversi.

00:31:17.205 --> 00:31:20.550
Flussi che dobbiamo descrivere.

00:31:20.550 --> 00:31:28.545
Così possiamo rompere questi
nelle loro parti reattive.

00:31:28.545 --> 00:31:32.145
Quindi questi sono tutti piuttosto poco eccitante.

00:31:32.145 --> 00:31:37.050
Questa è la stessa roba che
visto prima che è fondamentalmente

00:31:37.050 --> 00:31:39.180
solo dicendo Hey voglio creare questo

00:31:39.180 --> 00:31:42.630
osservabile che è l'ascolto
all'evento su cui è stato fatto clic.

00:31:42.630 --> 00:31:46.095
Quindi questo è l'aspetto centrale
di questo che è eccitante.

00:31:46.095 --> 00:31:51.825
Quindi creiamo un osservabile per
ciascuno di questi diversi elementi.

00:31:51.825 --> 00:31:54.030
Abbiamo il nostro login.

00:31:54.030 --> 00:31:55.470
Quindi è allora che fanno clic.

00:31:55.470 --> 00:31:56.805
Abbiamo il nostro logout.

00:31:56.805 --> 00:31:58.440
È allora che si disconnettono.

00:31:58.440 --> 00:32:01.785
Abbiamo la nostra cancellazione. Cioè
quando fanno clic su "Annulla".

00:32:01.785 --> 00:32:06.750
Abbiamo il cambio di testo
qui che è quando sono

00:32:06.750 --> 00:32:09.000
digitando il nome utente e abbiamo

00:32:09.000 --> 00:32:12.090
la Password qui quando sono
digitando la password.

00:32:12.090 --> 00:32:15.300
Poi, facciamo
una chiamata di richiesta Web falsa.

00:32:15.300 --> 00:32:17.670
Quindi questo è solo dimostrare.

00:32:17.670 --> 00:32:20.565
E 'essenzialmente solo
in attesa di due secondi.

00:32:20.565 --> 00:32:22.440
Poi, una volta che finisce genera

00:32:22.440 --> 00:32:26.265
un errore se qualche casuale
numero uguale a due.

00:32:26.265 --> 00:32:35.010
sì. Questa è la nostra applicazione.

00:32:35.010 --> 00:32:38.250
Questo è in osservabile
rappresentazione di

00:32:38.250 --> 00:32:41.985
tutti gli eventi che possono verificarsi
nell'applicazione, giusto?

00:32:41.985 --> 00:32:43.860
Così ora questo è dove

00:32:43.860 --> 00:32:47.680
l'aspetto di compostabilità viene
in gioco che è davvero cool.

00:32:48.500 --> 00:32:51.150
Ora, tutti questi
diversi osservabili

00:32:51.150 --> 00:32:53.220
prendere una vita propria.

00:32:53.220 --> 00:33:00.060
Quindi la totalità
la logica che vedete

00:33:00.060 --> 00:33:06.990
c'è incarnato con un abbastanza
semplice quantità di codice, giusto?

00:33:06.990 --> 00:33:12.780
Quindi questo è il nostro codice di convalida.

00:33:12.780 --> 00:33:14.940
Così ora quello che facciamo è
stiamo costruendo

00:33:14.940 --> 00:33:18.810
osservabili aggiuntivi su
questi altri osservabili.

00:33:18.810 --> 00:33:21.990
va bene? Ecco, questo è ciò che è
l'aspetto di componibilità di esso.

00:33:21.990 --> 00:33:23.640
Quindi il primo è che

00:33:23.640 --> 00:33:26.520
dire va bene vogliamo un
autenticato osservabile.

00:33:26.520 --> 00:33:29.580
L'osservabile autenticato
è l'utente che fa clic su

00:33:29.580 --> 00:33:33.060
"Login" e facendo clic su
disattivare "Richiesta Web".

00:33:33.060 --> 00:33:39.090
Così ora abbiamo composto questi due
idee di eventi osservabili.

00:33:39.090 --> 00:33:42.870
Ora abbiamo unito questi dati
flusso con un logout.

00:33:42.870 --> 00:33:47.250
Quindi, se un utente fa clic su "Logout"
allora questo dice "Ehi,

00:33:47.250 --> 00:33:48.735
Voglio che tu ti disconnetti."

00:33:48.735 --> 00:33:54.480
Quindi abbiamo l'intero
stato di autenticazione di

00:33:54.480 --> 00:34:00.525
l'applicazione rappresentata da
un nuovo autenticato osservabile.

00:34:00.525 --> 00:34:02.295
Autenticato osservabile.

00:34:02.295 --> 00:34:05.295
Ecco, questo è l'unico osservabile
ci preoccupiamo a questo punto.

00:34:05.295 --> 00:34:07.530
Ecco come ora possiamo usare questo

00:34:07.530 --> 00:34:09.540
osservabile altrove dove abbiamo

00:34:09.540 --> 00:34:14.940
vuole chiedere su ciò che è
l'utente autenticato.

00:34:14.940 --> 00:34:18.190
Sai di cosa c'è bisogno.

00:34:19.910 --> 00:34:22.620
Poi qui abbiamo la nostra convalida.

00:34:22.620 --> 00:34:24.720
La nostra convalida è una composizione di

00:34:24.720 --> 00:34:29.410
il nostro nome utente e la nostra password
lì che è bello.

00:34:29.570 --> 00:34:33.645
Quindi questo essenzialmente entra in gioco.

00:34:33.645 --> 00:34:35.894
Dice "Ehi,

00:34:35.894 --> 00:34:38.909
questi sono i punti dati
che rappresentano la validità."

00:34:38.909 --> 00:34:43.080
Trasforma questi eventi in un

00:34:43.080 --> 00:34:47.910
vero o un valore falso che abbiamo
può ora usare per dire: "Ok.

00:34:47.910 --> 00:34:53.860
Qual è lo stato degli eventi
che sono state arrivando? "

00:34:55.190 --> 00:34:58.515
Allora ora facciamoci

00:34:58.515 --> 00:35:01.455
mettere insieme- Ora possiamo mettere
tutta questa roba insieme.

00:35:01.455 --> 00:35:03.120
Questo è dove tipo di
come il funzionale

00:35:03.120 --> 00:35:05.295
aspetto di programmazione reattivo
entra in gioco.

00:35:05.295 --> 00:35:08.880
Ora possiamo mettere tutti questi diversi
osservabili insieme in

00:35:08.880 --> 00:35:10.485
un bel piccolo posto

00:35:10.485 --> 00:35:15.255
qui che descrive tutto
che sta per accadere.

00:35:15.255 --> 00:35:17.760
Quindi questa è la parte di
che è davvero pulito.

00:35:17.760 --> 00:35:22.995
Perché con questo
applicazione si può ottenere

00:35:22.995 --> 00:35:27.120
una portata prospettica su tutti i

00:35:27.120 --> 00:35:31.710
la logica solo per avere ragione
qui in questo punto di codice.

00:35:31.710 --> 00:35:36.060
Non c'è dover
saltare in giro o qualsiasi altra cosa.

00:35:36.060 --> 00:35:40.170
Si tratta di una posizione non modificabile basata su

00:35:40.170 --> 00:35:46.485
dati non modificabili da modificare
come funzionano questi punti dati.

00:35:46.485 --> 00:35:50.190
Quindi è bello perché
è un bel modo facile.

00:35:50.190 --> 00:35:53.490
Così come i dati che vengono
in questo valore di risultato qui

00:35:53.490 --> 00:35:57.450
è una struttura immutabile.

00:35:57.450 --> 00:36:00.435
Quindi, sulla base di questi dati si
conoscere l'osservabile autenticato.

00:36:00.435 --> 00:36:02.760
Quindi, quello che questo sta facendo
qui sta dicendo ciò che è

00:36:02.760 --> 00:36:06.315
lo stato di autenticazione è se
autenticato o meno.

00:36:06.315 --> 00:36:10.845
Valido significa se il
credenziali immesse come valide.

00:36:10.845 --> 00:36:12.360
Poi, sulla base di questo,

00:36:12.360 --> 00:36:17.320
impostare la visibilità
dell'applicazione.

00:36:20.170 --> 00:36:22.890
Sì, in modo da poter impostare
come la visibilità di

00:36:22.890 --> 00:36:26.200
l'applicazione. Quindi è pulito.

00:36:28.340 --> 00:36:31.905
Quindi vediamo.

00:36:31.905 --> 00:36:34.350
Ho un'altra demo molto veloce,

00:36:34.350 --> 00:36:36.820
solo uno piccolo.

00:36:39.350 --> 00:36:43.725
Oops, un po' troppo grande
lì. Ecco fatto.

00:36:43.725 --> 00:36:45.345
Lo vedono tutti, va bene?

00:36:45.345 --> 00:36:50.400
sì. Va bene. Ho questi
in come GitHub repos.

00:36:50.400 --> 00:36:53.520
Questo sta usando un po'
della roba reattiva dell'interfaccia utente,

00:36:53.520 --> 00:36:55.695
ma lasciatemi solo mostrare.

00:36:55.695 --> 00:37:00.730
Questo ha alcuni campioni diversi
che si può dare un'occhiata.

00:37:02.360 --> 00:37:10.240
Speriamo che funzioni. Davvero
già in esecuzione? Ecco fatto.

00:37:10.940 --> 00:37:14.980
Quindi molti di questi sono
cose semplici che si vedono.

00:37:15.050 --> 00:37:17.775
Diamo un'occhiata al
posizione demo dal momento che siamo

00:37:17.775 --> 00:37:19.905
poco tempo qui.

00:37:19.905 --> 00:37:21.900
Quindi l'idea della demo posizione

00:37:21.900 --> 00:37:24.810
è che è che si sta monitorando
puntatore del mouse.

00:37:24.810 --> 00:37:30.780
Questo ha un altro esempio popolare
per concetti reattivi.

00:37:30.780 --> 00:37:32.055
Quindi spingi verso il basso.

00:37:32.055 --> 00:37:33.660
Sta rilevando che si preme.

00:37:33.660 --> 00:37:34.740
Se sposti il mouse,

00:37:34.740 --> 00:37:36.000
ora sta rilevando che ti sei trasferito,

00:37:36.000 --> 00:37:37.380
e poi si lascia andare, e dà

00:37:37.380 --> 00:37:40.335
un'aggregazione di tutti i dati.

00:37:40.335 --> 00:37:49.380
Si è rotto un po'

00:37:49.380 --> 00:37:51.720
perché ho bisogno di avere
le descrizioni,

00:37:51.720 --> 00:37:56.080
ma è davvero pulito perché
tutto quello che dovete fare davvero,

00:37:56.120 --> 00:37:58.905
si dispone dell'evento premuto del puntatore.

00:37:58.905 --> 00:38:01.200
Quindi hai il puntatore
stampa che dice:

00:38:01.200 --> 00:38:03.840
"Ehi, ho premuto il mouse verso il basso."

00:38:03.840 --> 00:38:06.840
Ora, una volta che questo è
è successo, tu dici: "Ok,

00:38:06.840 --> 00:38:10.395
Desidero iscrivermi
il puntatore viene spostato.

00:38:10.395 --> 00:38:14.170
Quindi questo è ora il puntatore
essere spostato in giro.

00:38:14.240 --> 00:38:16.800
Mentre si muove ora,

00:38:16.800 --> 00:38:20.085
si sta tirando tutti questi dati
insieme qui,

00:38:20.085 --> 00:38:23.145
e poi l'operatore a due liste, qui,

00:38:23.145 --> 00:38:24.960
è ora in grado di
aggregare tutti quei dati

00:38:24.960 --> 00:38:27.405
in un unico set di dati.

00:38:27.405 --> 00:38:29.760
Poi qui, la prendere fino a che è stato

00:38:29.760 --> 00:38:32.220
l'unica operazione che
che stavamo mostrando qui.

00:38:32.220 --> 00:38:34.170
Dice: "Ehi, va bene,
Voglio solo che tu

00:38:34.170 --> 00:38:36.270
prendere questi dati e dire
i puntatori rilasciati.

00:38:36.270 --> 00:38:38.309
Così si ottiene questo davvero
interazione fresco

00:38:38.309 --> 00:38:40.020
di tutti questi eventi per dire,

00:38:40.020 --> 00:38:41.940
perché tutto quello che volevi veramente
per dire è che voglio muovermi

00:38:41.940 --> 00:38:44.130
il mouse intorno e quando
hanno lasciato andare il topo,

00:38:44.130 --> 00:38:45.810
Voglio tutti i dati che c'erano.

00:38:45.810 --> 00:38:47.160
Così si può ottenere tutto questo

00:38:47.160 --> 00:38:50.505
rappresentato in questo bello
piccolo abbonamento qui.

00:38:50.505 --> 00:38:55.120
Quindi questo è uno dei
questi esempi principali.

00:38:57.130 --> 00:39:03.360
Sì, quindi questo è un rapido primer
nei concetti reattivi.

00:39:04.690 --> 00:39:08.940
C'è un sacco di
buoni quadri là fuori.

00:39:11.210 --> 00:39:16.740
Oops, non è d'aiuto. Ecco fatto.

00:39:16.740 --> 00:39:23.280
sì. Ecco, questa è l'idea alla base
la maggior parte degli osservabili.

00:39:23.280 --> 00:39:25.530
Michael parlerà
un po 'di più sull'utilizzo

00:39:25.530 --> 00:39:28.545
questi quadri con MVVM.

00:39:28.545 --> 00:39:32.880
C'è un sacco di davvero potente
strumenti come i dati dinamici.

00:39:32.880 --> 00:39:35.100
Selezionare Dynamic Data, è

00:39:35.100 --> 00:39:37.590
una piattaforma davvero cool

00:39:37.590 --> 00:39:41.985
per superpotere nelle vostre liste
con osservabili.

00:39:41.985 --> 00:39:43.890
Quindi l'idea è che si può

00:39:43.890 --> 00:39:46.995
essenzialmente fare
tutto e osservabile.

00:39:46.995 --> 00:39:49.660
Puoi firmarlo,
Non lo sapevo.

00:39:51.470 --> 00:39:53.610
Quindi immagino che molto veloce,

00:39:53.610 --> 00:39:55.960
qualcuno ha domande?

00:39:57.410 --> 00:40:00.720
Sì, Sam. Beh, sì.

00:40:00.720 --> 00:40:04.095
Andiamo lì. Ci sarà
fare domande circa 35 minuti.

00:40:04.095 --> 00:40:05.520
>> Quindi parlare di

00:40:05.520 --> 00:40:10.380
la divulgazione del
[incomprensibile] e tutta quella roba.

00:40:10.380 --> 00:40:14.220
Parlate del perché gli osservabili
sono migliori [non udibili].

00:40:14.220 --> 00:40:20.460
>> Sì, così ho

00:40:20.460 --> 00:40:24.045
credo che direi perché
la gestione-Quindi la domanda era,

00:40:24.045 --> 00:40:25.680
con la perdita di memoria,

00:40:25.680 --> 00:40:28.290
perché è il fatto che ritorna

00:40:28.290 --> 00:40:31.245
un usa e getta meglio prima
dire la gestione della memoria?

00:40:31.245 --> 00:40:33.090
L'idea c'è solo, sì,

00:40:33.090 --> 00:40:37.230
è che è il fatto che
è la vita di

00:40:37.230 --> 00:40:43.665
l'osservabile è un aspetto
dell'abbonamento.

00:40:43.665 --> 00:40:46.920
Quindi, quando si sottoscrive
ad esso, si torna,

00:40:46.920 --> 00:40:49.395
perché ogni volta che si ottiene
un usa e getta da qualcosa,

00:40:49.395 --> 00:40:51.270
sai che hai
di smaltirlo.

00:40:51.270 --> 00:40:54.630
Come se questo era il paradigma che usiamo.

00:40:54.630 --> 00:40:57.060
Questa è l'idea al riguardo.

00:40:57.060 --> 00:41:01.365
E 'che con lo sfiato
specialmente per i nuovi programmatori,

00:41:01.365 --> 00:41:03.660
sono sempre andando a
fare che come errore

00:41:03.660 --> 00:41:07.700
dove sono come qualcosa di

00:41:07.700 --> 00:41:08.810
andando a sopravvivere qualcos'altro

00:41:08.810 --> 00:41:10.250
perché devi capirlo.

00:41:10.250 --> 00:41:15.360
Ma un usa e getta è
un concetto molto semplice.

00:41:15.360 --> 00:41:19.155
Quindi, avendo che come parte
dell'abbonamento

00:41:19.155 --> 00:41:22.860
rende la gestione della memoria
scenari più semplici.

00:41:22.860 --> 00:41:25.440
sì.

00:41:25.440 --> 00:41:26.940
Altre domande?

00:41:26.940 --> 00:41:28.727
sì.

00:41:28.727 --> 00:41:35.250
>> [non udibile].

00:41:35.250 --> 00:41:39.060
>> sì. Quindi la domanda era:

00:41:39.060 --> 00:41:41.985
è possibile utilizzare la programmazione reattiva

00:41:41.985 --> 00:41:45.060
con cose come compiti o
programmazione asincrona?

00:41:45.060 --> 00:41:50.865
sì. Quindi un compito è in modo efficace
una notifica di un punto.

00:41:50.865 --> 00:41:53.355
Quindi, quando hai un compito,

00:41:53.355 --> 00:41:57.210
ci sono tre punti dati per
un compito che è esattamente come

00:41:57.210 --> 00:42:02.175
il nostro iteratore quando stavamo indicando.

00:42:02.175 --> 00:42:05.040
Quindi, quando scrivi un compito- Ok,

00:42:05.040 --> 00:42:06.615
Non so dove sia
in arrivo. Va bene.

00:42:06.615 --> 00:42:08.190
Quindi, quando hai un compito,

00:42:08.190 --> 00:42:14.145
si crea l'attività in modo che sia
che avete all'inizio,

00:42:14.145 --> 00:42:19.724
poi si avvia l'attività
così ora è in esecuzione,

00:42:19.724 --> 00:42:23.355
e poi il compito produce un valore,

00:42:23.355 --> 00:42:26.445
questo è il tuo punto risultati
che nessuno di noi sta digitando,

00:42:26.445 --> 00:42:29.970
e poi si completa a
il completamento di questo.

00:42:29.970 --> 00:42:31.440
Quindi, a quel punto,

00:42:31.440 --> 00:42:35.190
si dispone di un punto dati osservabile.

00:42:35.190 --> 00:42:40.680
Così usa e getta crea cose

00:42:40.680 --> 00:42:42.900
che funzionano esattamente contro il compito in modo

00:42:42.900 --> 00:42:45.180
che è possibile creare un
rispetto al compito.

00:42:45.180 --> 00:42:49.125
Quindi quello che accadrà è quando
ti iscrivi a quell'osservabile,

00:42:49.125 --> 00:42:54.494
è che sarà effettivamente avviare il compito
e poi una volta che questo accade,

00:42:54.494 --> 00:42:56.190
che riprende un risultato.

00:42:56.190 --> 00:42:59.655
In modo che produce un valore
e poi si completa.

00:42:59.655 --> 00:43:01.410
Allora questa è un'altra cosa
che è davvero super

00:43:01.410 --> 00:43:03.600
utile perché se tale attività fallisce,

00:43:03.600 --> 00:43:05.040
si ottiene la vostra roba con

00:43:05.040 --> 00:43:07.485
osservabili in cui si
può intercettare l'eccezione.

00:43:07.485 --> 00:43:13.500
Così, per esempio, gli scenari
come async void, per esempio.

00:43:13.500 --> 00:43:16.575
Async void è un non-problemaAsync void is a non-issue
con osservabili.

00:43:16.575 --> 00:43:18.495
Non devi mai preoccuparti

00:43:18.495 --> 00:43:21.970
async void Se sei
facendo osservabili.

00:43:22.040 --> 00:43:26.520
Così, per esempio, si sa come si
forse vuole avviare un'attività asincrona

00:43:26.520 --> 00:43:28.050
da un costruttore o cose come

00:43:28.050 --> 00:43:30.060
che o questi problemi da
quelli con osservabili,

00:43:30.060 --> 00:43:31.200
che non è nemmeno uno scenario,

00:43:31.200 --> 00:43:34.320
perché basta avvolgere il compito in un

00:43:34.320 --> 00:43:36.180
osservabile e poi si ha

00:43:36.180 --> 00:43:39.225
il comportamento dell'eccezione come parte
dell'osservabile con il compito.

00:43:39.225 --> 00:43:40.710
Quindi sì, funzionano.

00:43:40.710 --> 00:43:42.060
Sono ottimi per i compiti.

00:43:42.060 --> 00:43:43.770
Così ci dimentico chi fa un discorso.

00:43:43.770 --> 00:43:46.260
Jeffrey o qualcosa di simile
che fa un discorso su questo;

00:43:46.260 --> 00:43:48.015
parlando di come i compiti sono

00:43:48.015 --> 00:43:50.010
super male e si dovrebbe
basta usare gli osservabili.

00:43:50.010 --> 00:43:51.360
Ma sì, una volta che si inizia a utilizzare

00:43:51.360 --> 00:43:53.685
osservabili in particolare
nel codice dell'interfaccia utente,

00:43:53.685 --> 00:43:55.260
ti basta effettivamente solo mettere

00:43:55.260 --> 00:43:57.420
una facciata di fronte a tutti
dei vostri compiti, perché

00:43:57.420 --> 00:44:02.080
diventa molto più semplice
gestire attraverso osservabili.

00:44:02.450 --> 00:44:04.905
Altre domande?

00:44:04.905 --> 00:44:07.840
Ho lo shhh.

00:44:09.380 --> 00:44:12.870
Posso prendere un altro
domanda? No? Va bene, no.

00:44:12.870 --> 00:44:15.075
Ti risponderò
domanda subito dopo.

00:44:15.075 --> 00:44:17.340
Bello. Quindi sì, sono Shane.

00:44:17.340 --> 00:44:20.500
Questi sono i miei osservabili.