WEBVTT

00:00:00.000 --> 00:00:03.190
>> Wszystko w porządku. Cześć.
Jak wszyscy robią?

00:00:03.380 --> 00:00:08.280
Po czwarte w drodze
Nasz Xam Summit tutaj.

00:00:08.280 --> 00:00:12.870
Więc tak, jestem Shane
Neuville. Pisane to prawda?

00:00:12.870 --> 00:00:17.715
Tak. Mirosław. Jestem
z zespołem platformy Xamarin Forms.

00:00:17.715 --> 00:00:20.280
Przed być z formularzy platformy Xamarin,

00:00:20.280 --> 00:00:23.490
Pracowałem przyzwoitą kwotę
z ReactiveUI.

00:00:23.490 --> 00:00:26.160
Więc nadal staram się mistrz
że tak samo jak ja

00:00:26.160 --> 00:00:29.310
może nawet z poziomu Microsoft.

00:00:29.310 --> 00:00:35.970
Więc dyskusja tutaj będzie
w znacznym stopniu na reaktywne rozszerzenia,

00:00:35.970 --> 00:00:39.990
konkretnie tylko pojęcia
za napędem reaktywnym,

00:00:39.990 --> 00:00:42.990
jak oni blisko wydarzeń.

00:00:42.990 --> 00:00:44.975
Później Michael zamierza zrobić

00:00:44.975 --> 00:00:47.600
obszerniejsze rozmowy na
mapowanie na jak

00:00:47.600 --> 00:00:52.040
MVVM i jak moc
RAM dla tego.

00:00:52.040 --> 00:00:56.055
Więc, aby zacząć z tym,

00:00:56.055 --> 00:00:59.305
ile osób wykorzystali
Przedłużania reaktywne,

00:00:59.305 --> 00:01:01.350
tylko dostać, "Och, hej. To miłe. "?

00:01:01.350 --> 00:01:02.895
Za każdym razem zapytałem,
jest więcej rąk.

00:01:02.895 --> 00:01:08.040
Więc to dobry znak. Zobaczmy.

00:01:08.040 --> 00:01:12.250
Tak jak wielu ludzi myśli, że mówię
o JavaScript i ReactJS?

00:01:12.250 --> 00:01:15.250
Ten facet tam, go? W porządku.

00:01:16.130 --> 00:01:20.150
Tak więc niektóre z języków
również zaczął się klarowny.

00:01:20.150 --> 00:01:23.450
Czy ktoś myśli, że zamierzam
Dyskusja na temat obserwowalnych zbiorów

00:01:23.450 --> 00:01:26.940
przez około godzinę? Nr. W porządku.

00:01:26.940 --> 00:01:29.990
Tak więc, ta ramka

00:01:29.990 --> 00:01:33.530
staje się trochę mniej
istotne, jak rozmowy idą dalej.

00:01:33.530 --> 00:01:37.580
Nie było na pewno
nieporozumień, które zaczęły się.

00:01:37.580 --> 00:01:39.980
Więc pamiętam pierwszy
czas słyszałem o ReactJS.

00:01:39.980 --> 00:01:42.955
Robiłem RxJS od jakiegoś czasu.

00:01:42.955 --> 00:01:45.380
To było około pięciu minut
do rozmowy,

00:01:45.380 --> 00:01:48.695
Zdałem sobie sprawę, że nie
tej samej konwersacji.

00:01:48.695 --> 00:01:51.890
Więc nie ma naprawdę

00:01:51.890 --> 00:01:55.920
wszelkie stosunki tam oprócz
pierwszych pięciu liter.

00:01:57.410 --> 00:02:01.105
Kątowy rozpoczął
intensywnie korzysta z RxJS.

00:02:01.105 --> 00:02:03.260
Tak kątowy jest prawdopodobnie
bardziej synonimem

00:02:03.260 --> 00:02:05.870
z RxJS w tym momencie, ale tak.

00:02:05.870 --> 00:02:08.810
Następnie następny obszar
gdzie ludzie się wyrzucać

00:02:08.810 --> 00:02:12.305
ma do czynienia z
ReactiveX i ReactiveUI,

00:02:12.305 --> 00:02:14.345
Punkty podziału.

00:02:14.345 --> 00:02:21.810
Więc ReactiveX jest
koncepcji agnostyki.

00:02:21.810 --> 00:02:25.760
Więc koncepcja ReactiveX

00:02:25.760 --> 00:02:28.940
jest wdrażany w całej
wielu struktur.

00:02:28.940 --> 00:02:35.390
Więc jest Coco, Java, RxJS.

00:02:35.390 --> 00:02:40.515
Jest cały pokosu języków
które wdrażają pojęcia.

00:02:40.515 --> 00:02:45.090
Następnie ReactiveUI jest warstwą MVVM

00:02:45.090 --> 00:02:48.750
, który pomaga plug ReactiveX
do MVVM.

00:02:48.750 --> 00:02:52.905
Więc kiedy ludzie są
mówienie o reaktywnej,

00:02:52.905 --> 00:02:54.705
nie tylko mówią
o ReactiveUI.

00:02:54.705 --> 00:02:55.820
Mówią głównie o

00:02:55.820 --> 00:02:59.090
funkcjonalne programowanie reaktywne i

00:02:59.090 --> 00:03:02.810
jak obserwowalne oparte
Programowanie paradygmaty pracy.

00:03:02.810 --> 00:03:05.870
Dlatego aspekt ReactiveX jest

00:03:05.870 --> 00:03:10.655
w dużej mierze to, co mówi
będzie obracać się wokół,

00:03:10.655 --> 00:03:15.245
który będzie dobrym prekursorem
na rozmowę Michaela później.

00:03:15.245 --> 00:03:18.830
Więc dlaczego to sygnał na mnie?

00:03:18.830 --> 00:03:20.240
Trzymaj się. Pewnie
może nie mam go

00:03:20.240 --> 00:03:22.845
Wyróżnione. Nie idziemy.

00:03:22.845 --> 00:03:29.300
Więc niech rozbić co
Jesteśmy naprawdę patrząc tutaj.

00:03:29.300 --> 00:03:32.420
Porozmawiajmy o
wydarzeń naprawdę szybko.

00:03:32.420 --> 00:03:35.570
Jak więc subskrybować
Zdarzenia? To wszystko jest całkiem proste.

00:03:35.570 --> 00:03:37.945
Wszyscy widzieliśmy ten kod przed.

00:03:37.945 --> 00:03:41.190
Nie idź. Całkiem ekscytujące, prawda?

00:03:41.190 --> 00:03:46.085
Tak skutecznie, masz
wydawcy po lewej stronie.

00:03:46.085 --> 00:03:48.260
Masz swoje wydarzenia
, a następnie

00:03:48.260 --> 00:03:50.990
obserwatora po prawej stronie.

00:03:50.990 --> 00:03:57.230
Tak więc, jest to podstawowe wydarzenie
wzór powiadomienia,

00:03:57.230 --> 00:03:58.760
podstawowy wzorzec obserwatora.

00:03:58.760 --> 00:04:02.030
Tak to była składnia w języku C# jeden.

00:04:02.030 --> 00:04:04.190
Skutecznie, Górna
jeden robi to samo

00:04:04.190 --> 00:04:06.395
jak dno, ale cukier syntaktyczny.

00:04:06.395 --> 00:04:10.725
Warto więc rozbić to, co jest wydarzeniem.

00:04:10.725 --> 00:04:14.005
Tak więc wydarzenie jest zasadniczo,

00:04:14.005 --> 00:04:21.095
to seria pojedynczych rzeczy
które występują w danych produktu.

00:04:21.095 --> 00:04:25.260
Więc jeśli wpisuję moje imię,

00:04:25.990 --> 00:04:29.930
Wpisuja S, nie ma
wydarzenie, h i wydarzenie,

00:04:29.930 --> 00:04:33.635
a i wydarzenie, myślę, że widzisz
gdzie wszyscy idą,

00:04:33.635 --> 00:04:39.080
i reprezentacja
danych jest tutaj.

00:04:39.080 --> 00:04:41.990
Tak to jest zestaw danych, które mają

00:04:41.990 --> 00:04:46.325
na podstawie tych zdarzeń.

00:04:46.325 --> 00:04:49.220
Tak to jest Twoje wydarzenie.

00:04:49.220 --> 00:04:51.455
Więc nic zbyt umysł-dmuchanie
w tym momencie.

00:04:51.455 --> 00:04:55.340
Więc kroki, aby przestać obserwować zdarzenie.

00:04:55.340 --> 00:04:58.000
Więc jak zatrzymać
obserwować wydarzenie?

00:04:58.000 --> 00:05:00.600
Wszyscy niezauważone
przednie wydarzenia, prawda?

00:05:00.600 --> 00:05:01.760
Jak wszyscy mówili: "Hej, nie

00:05:01.760 --> 00:05:03.620
dłużej dbać o to, co
to coś się dzieje. "

00:05:03.620 --> 00:05:08.960
Tak zwykle proces
dowiedzieć się, jak

00:05:08.960 --> 00:05:11.720
Aby anulować subskrypcję rozpoczyna się

00:05:11.720 --> 00:05:15.155
z klientem narzekają
aplikacji jest powolne.

00:05:15.155 --> 00:05:19.070
Więc pliki klienta
problem i mówi: "Hej,

00:05:19.070 --> 00:05:21.840
Moja aplikacja spowalnia po jej użyciu.

00:05:22.670 --> 00:05:24.690
Co się dzieje źle?

00:05:24.690 --> 00:05:27.075
Im bardziej używam go,
to nie działa. "

00:05:27.075 --> 00:05:30.550
Więc po pierwsze, nie wierzysz im.

00:05:31.400 --> 00:05:35.090
Myślisz, że
zainstalowalem cos takiego

00:05:35.090 --> 00:05:37.730
Wygaszacz ekranu Dilberta, który bierze

00:05:37.730 --> 00:05:39.980
całe okno przeglądarki
czy jakoś tak.

00:05:39.980 --> 00:05:42.290
Ponieważ po uruchomieniu
aplikacji i

00:05:42.290 --> 00:05:44.795
używasz go do
około 15 sekund, jest szybki.

00:05:44.795 --> 00:05:46.895
Wszystko działa świetnie.
To reaguje.

00:05:46.895 --> 00:05:51.670
Zorientowali się, że jest idealny.

00:05:51.670 --> 00:05:54.435
Tak więc, jesteś jak "wszystko
Prawo. Myślę, że ich wierzę ".

00:05:54.435 --> 00:05:58.530
Więc w tym momencie, kurz
wyłączyć kapelusz debugowania,

00:05:58.530 --> 00:06:01.110
odczytać wszystkie
testy i blogi na temat

00:06:01.110 --> 00:06:04.185
do analizowania ramek stosu,

00:06:04.185 --> 00:06:06.675
i zaczynasz ciągnięcie wszystko.

00:06:06.675 --> 00:06:08.145
Otrzymujesz stos DOMs.

00:06:08.145 --> 00:06:10.925
Patrzysz, jak długo
obiekty są żywe.

00:06:10.925 --> 00:06:13.055
Robisz to w kółko.

00:06:13.055 --> 00:06:15.740
Wreszcie, jesteś coraz w dół.

00:06:15.740 --> 00:06:18.290
Istnieje wiele patrząc na
strzałki wskazujące na rzeczy,

00:06:18.290 --> 00:06:19.940
i zastanawiasz się, jakie przedmioty mają znaczenie,

00:06:19.940 --> 00:06:22.280
i odjęcie tego
od tego momentu, aż

00:06:22.280 --> 00:06:23.900
wreszcie zobaczyć, że nie

00:06:23.900 --> 00:06:25.595
było to, że jeden wiersz kodu lub
Zapomniałeś napisać.

00:06:25.595 --> 00:06:27.990
Jesteś jak "Och, człowieku".
Następnie, nagle,

00:06:27.990 --> 00:06:30.195
wszystko zaczyna działać bardzo szybko.

00:06:30.195 --> 00:06:33.699
Więc tak, mam na myśli, w zasadzie,

00:06:35.210 --> 00:06:38.280
subskrybować i wypisać się z nich.

00:06:38.280 --> 00:06:43.980
Więc to jest jego semantyka.

00:06:43.980 --> 00:06:48.345
Ale semantyczne, to
trochę gnarly czuję.

00:06:48.345 --> 00:06:52.655
Ponieważ jeden, trzeba
Pamiętaj, aby zrobić dwie rzeczy.

00:06:52.655 --> 00:06:55.130
Zawsze muszę pamiętać
zrobić więcej niż jedną rzecz,

00:06:55.130 --> 00:06:57.850
masz zamiar zakończyć się niepowodzeniem
zwykle w programowaniu.

00:06:57.850 --> 00:07:00.695
Dodatkowo musisz zachować
swoje referencje do wszystkiego.

00:07:00.695 --> 00:07:04.040
Tak więc w celu
tego drugiego,

00:07:04.040 --> 00:07:05.210
potrzebujesz wszystkiego, co w

00:07:05.210 --> 00:07:08.125
Twój pierwszy zrobić
wszystko w swoim drugim,

00:07:08.125 --> 00:07:11.930
jak trzeba
utrzymania tych pomysłów.

00:07:11.930 --> 00:07:16.725
Tak więc w ogólnym zarządzaniu zdarzeniami
jest po prostu, to bałagan.

00:07:16.725 --> 00:07:20.015
To nie jest najczystszym typem
działania.

00:07:20.015 --> 00:07:21.290
Mam na myśli, jak powiedzmy,

00:07:21.290 --> 00:07:26.600
zależy tylko od
pojedyncze wydarzenie, na przykład

00:07:26.600 --> 00:07:28.465
jak wszyscy napisali ten kod,

00:07:28.465 --> 00:07:31.340
gdzie chcesz
wypisać się z czegoś podobnego

00:07:31.340 --> 00:07:35.600
tylko chciał ogień jeden.

00:07:35.600 --> 00:07:38.915
Więc powiedzmy, jak pojawiające się strony
lub coś z tego rodzaju,

00:07:38.915 --> 00:07:42.140
więc trzeba mieć
odniesienie u góry

00:07:42.140 --> 00:07:45.830
tak, aby zamknięcie
ma do niego dostęp,

00:07:45.830 --> 00:07:47.975
następnie przypiszesz program obsługi,

00:07:47.975 --> 00:07:50.255
a następnie robisz
obsługi na końcu.

00:07:50.255 --> 00:07:55.280
Więc jest to kolejna ceremonia

00:07:55.280 --> 00:07:59.150
który pochodzi z
zestawu operacji.

00:07:59.150 --> 00:08:03.050
Więc to wygląda znajomo. Jest
Każdy napisał ten kod przed?

00:08:03.050 --> 00:08:05.790
Tak? W porządku.

00:08:06.930 --> 00:08:12.655
Więc i tu jestem jeszcze
rozmawiać o wydarzeniach.

00:08:12.655 --> 00:08:14.860
To jest to, co nazywam moją
IObservable infomercial.

00:08:14.860 --> 00:08:16.360
Gdzie coś zrobić
szalony i jesteś jak,

00:08:16.360 --> 00:08:17.680
"Och, mój Boże, to jest tak straszne."

00:08:17.680 --> 00:08:22.135
To nie jest takie złe. Ale tutaj
Wskazuję wszystkie rzeczy.

00:08:22.135 --> 00:08:24.115
To nie jest Xamarin Forms,

00:08:24.115 --> 00:08:26.725
podczas podłączania do zdarzenia.

00:08:26.725 --> 00:08:29.485
Więc drut do zdarzenia,

00:08:29.485 --> 00:08:32.425
trzeba znaleźć w porządku,
gdzie jest moje aspekty rozporządzania?

00:08:32.425 --> 00:08:33.835
OK, to tutaj.

00:08:33.835 --> 00:08:37.330
Muszę upewnić się, że
zutylizować ze zdarzeń i

00:08:37.330 --> 00:08:41.350
wszystkie te rzeczy są w różnych
lokalizacje w całym pliku.

00:08:41.350 --> 00:08:42.730
Są to wszystkie te rzeczy.

00:08:42.730 --> 00:08:44.290
Ta ceremonia trzeba zrobić

00:08:44.290 --> 00:08:46.240
ze wszystkimi tymi zdarzeniami
systemów zarządzania.

00:08:46.240 --> 00:08:48.790
Spójrz w prawo tam,
muszą się do niego zapisać.

00:08:48.790 --> 00:08:51.385
Następnie masz obsługi w dół tutaj.

00:08:51.385 --> 00:08:52.810
Masz do czynienia z danymi w

00:08:52.810 --> 00:08:55.180
oddzielne miejsce i
następnie pochyla się tutaj.

00:08:55.180 --> 00:08:59.635
To bardzo
z odłączonym doświadczeniem.

00:08:59.635 --> 00:09:01.240
Więc tutaj nawet wpisane
złe rzeczy,

00:09:01.240 --> 00:09:03.625
Jestem tak fluszony do jak ciężko jest.

00:09:03.625 --> 00:09:07.720
Ale tak. Więc mam infomercial,
gdzie nie Soda iść?

00:09:07.720 --> 00:09:13.225
Więc to jest rzecz.

00:09:13.225 --> 00:09:18.175
Więc wydarzenia są te pojedyncze
synchroniczne punkty danych.

00:09:18.175 --> 00:09:20.650
Tak więc otrzymujesz zdarzenia zmiany tekstu

00:09:20.650 --> 00:09:22.690
i wszystko, co masz, to
tego zdarzenia zmiany tekstu.

00:09:22.690 --> 00:09:24.460
Po prostu masz ten list.
Po prostu masz ten list

00:09:24.460 --> 00:09:27.195
S, że masz do czynienia.

00:09:27.195 --> 00:09:29.145
Ale co, jeśli chcesz
zrobić więcej z tym?

00:09:29.145 --> 00:09:31.200
Co zrobić, gdy
masz wydarzenie,

00:09:31.200 --> 00:09:33.840
Bardzo rzadko obchodzi Cię
o jednym zdarzeniu.

00:09:33.840 --> 00:09:36.680
Dbamy o dane
zestaw zdarzeń.

00:09:36.680 --> 00:09:37.870
Dbamy o wszystko, co

00:09:37.870 --> 00:09:40.510
dzieje się w okresie czasu.

00:09:40.510 --> 00:09:43.750
Więc co zrobić, jeśli chcesz zrobić
coś bardzo ekscytującego.

00:09:43.750 --> 00:09:45.220
Więc co, jeśli chcesz powiedzieć,

00:09:45.220 --> 00:09:47.590
pominąć pierwsze pięć wydarzeń i

00:09:47.590 --> 00:09:50.050
wtedy tylko troszczyć się o następne cztery,

00:09:50.050 --> 00:09:52.015
Następnie chcesz rozdebć wydarzenia,

00:09:52.015 --> 00:09:56.139
więc jeśli piszesz Super-Fast
Poczekaj tylko dwie sekundy,

00:09:56.139 --> 00:09:57.610
Następnie Załóżmy, że chcesz odfiltrować

00:09:57.610 --> 00:09:59.215
wszelkie zdarzenia, które są kwiat kukurydzy niebieski

00:09:59.215 --> 00:10:02.545
tylko dlatego, że to okropny kolor
ewentualnie, nie wiem.

00:10:02.545 --> 00:10:05.110
Następnie chcesz

00:10:05.110 --> 00:10:07.120
inauguracją żądania internetowego
a potem zaczynają się,

00:10:07.120 --> 00:10:08.860
tak ty potrzeba wobec just rzucać ów daleko.

00:10:08.860 --> 00:10:12.220
Podobnie jak ten typ wzoru jest

00:10:12.220 --> 00:10:16.900
Bardzo często, o ile
zarządzanie zdarzeniami,

00:10:16.900 --> 00:10:22.630
zwłaszcza w ramach MVVM i
rzeczy, które są bardziej oparte na interfejsie użytkownika.

00:10:22.630 --> 00:10:25.420
Zawsze reagujesz na

00:10:25.420 --> 00:10:29.830
względem przychodzących punktów danych
z utraconą łączność.

00:10:29.830 --> 00:10:31.240
Tak jak co, jeśli
łączność zostanie

00:10:31.240 --> 00:10:33.460
utracone na żądania sieci Web do punktu?

00:10:33.460 --> 00:10:34.870
Jak przerwać

00:10:34.870 --> 00:10:39.745
tego żądania sieci Web raz
łączność jest stracone?

00:10:39.745 --> 00:10:48.460
Jak to zrobić w wiarygodny sposób
łatwe w zarządzaniu.

00:10:48.460 --> 00:10:50.680
Dlatego wszystkie te pojęcia

00:10:50.680 --> 00:10:58.060
bardzo jasne wersje czasowników
które je odwzorowywane w reaktywnej.

00:10:58.060 --> 00:10:59.830
Więc to wszystko
rzeczywiste rzeczy, które można

00:10:59.830 --> 00:11:02.590
zastosowanie w reaktywności do wyrażania

00:11:02.590 --> 00:11:07.795
wszystkie te próby nad danymi,

00:11:07.795 --> 00:11:09.880
strumienia zdarzeń rocznie.

00:11:09.880 --> 00:11:13.720
W porządku. Więc co jeszcze
możemy zrobić z wydarzeniami?

00:11:13.720 --> 00:11:19.010
Nie tak bardzo.
Bardzo proste podstawowe wzorce.

00:11:19.260 --> 00:11:23.725
Więc to moje łzy w dół wydarzeń.

00:11:23.725 --> 00:11:26.110
Więc w tym momencie, jeśli
naprawdę nie używałeś

00:11:26.110 --> 00:11:28.450
reaktywne prawdopodobnie lubisz,
"Och, byłem tak straszny.

00:11:28.450 --> 00:11:31.600
Robiłem to źle
cały czas, "a ty masz

00:11:31.600 --> 00:11:33.610
kryzys egzystencjalny o

00:11:33.610 --> 00:11:37.970
wszystkie problemy, które nie
wiesz, że masz, że teraz masz.

00:11:39.900 --> 00:11:45.580
Więc Przetłumacz to
do Observables.

00:11:45.580 --> 00:11:48.370
Więc IObservable został
około chwilę.

00:11:48.370 --> 00:11:49.660
To w istocie tak jak

00:11:49.660 --> 00:11:52.855
modelu publikowania subskrypcji

00:11:52.855 --> 00:11:55.900
to wewnątrz rdzenia
ramy of.Net i

00:11:55.900 --> 00:11:59.005
następnie ReactiveX jest więcej

00:11:59.005 --> 00:12:04.465
wyrazem sposobu interakcji
z tymi Observables.

00:12:04.465 --> 00:12:11.245
Więc niech rozbić co
obserwowalny jest tutaj.

00:12:11.245 --> 00:12:15.020
Więc jest to zasadniczo
Wzorzec obserwatora.

00:12:18.690 --> 00:12:21.790
Zasadniczo, to
to samo co wydarzenie.

00:12:21.790 --> 00:12:26.000
Wydarzenie jest skutecznie
wzorzec obserwatora.

00:12:27.420 --> 00:12:30.775
Więc masz tutaj swoje wydarzenie,

00:12:30.775 --> 00:12:34.449
Twój program obsługi i wydawcy

00:12:34.449 --> 00:12:37.870
i to jest analogiczne
do tego prawa tutaj.

00:12:37.870 --> 00:12:42.865
Więc masz swoje dostrzegalne
oglądając,

00:12:42.865 --> 00:12:45.070
robi to samo.

00:12:45.070 --> 00:12:47.980
Więc masz ten sam pomysł.

00:12:47.980 --> 00:12:51.220
Skutecznie, można zrobić dokładnie
to samo z obydwoma

00:12:51.220 --> 00:12:54.925
warstwę bazową i
uzyskać punkty danych.

00:12:54.925 --> 00:12:56.650
Ale ekscytująca rzecz teraz,

00:12:56.650 --> 00:12:58.285
więc to jest, gdzie ekscytujące punkty

00:12:58.285 --> 00:13:00.620
wszystko wchodzi w grę.

00:13:03.690 --> 00:13:07.540
Ze zdarzeniem nie
naprawdę nic.

00:13:07.540 --> 00:13:09.385
Po prostu masz jakieś wydarzenie.

00:13:09.385 --> 00:13:11.770
Ale teraz z obserwowalnych,

00:13:11.770 --> 00:13:13.510
masz reprezentację
tego zdarzenia.

00:13:13.510 --> 00:13:17.095
Rzeczywiście masz jak obiekt danych
że można robić rzeczy z.

00:13:17.095 --> 00:13:22.645
Więc to jest różnica
pomiędzy posiadaniem jednej pozycji

00:13:22.645 --> 00:13:25.360
listę zamiast innych niż

00:13:25.360 --> 00:13:28.675
po wypowiedz całą listę
które można teraz obsługiwać.

00:13:28.675 --> 00:13:32.140
Więc to, gdzie
różnice są w grze.

00:13:32.140 --> 00:13:35.590
Można więc myśleć o
zauważalne bardzo

00:13:35.590 --> 00:13:39.550
jako wzorzec iteratora.

00:13:39.550 --> 00:13:42.340
Więc to jest zrobione z reactivex. Io

00:13:42.340 --> 00:13:44.485
który jest jednym z głównych źródeł,

00:13:44.485 --> 00:13:45.520
który jest naprawdę dobrym źródłem.

00:13:45.520 --> 00:13:48.100
Ma on rozkład
wszystkich operatorów i wszystko.

00:13:48.100 --> 00:13:49.930
Więc mam link do niego tam
u dołu dla Ciebie.

00:13:49.930 --> 00:13:56.605
tak to jest efektywne mapowanie

00:13:56.605 --> 00:14:02.170
obserwowalny pomysł, aby

00:14:02.170 --> 00:14:03.925
te same rzeczy, które można
zrobić z iteratora.

00:14:03.925 --> 00:14:05.635
Jest prawie doskonały

00:14:05.635 --> 00:14:08.560
porównania jeden-do-jednego
tam, kiedy iterować.

00:14:08.560 --> 00:14:11.605
Tak iteratora jest jak IEnumerator.

00:14:11.605 --> 00:14:13.945
To jest odpowiednik.

00:14:13.945 --> 00:14:18.085
Co to jest odpowiednik IEnumerator
do IObservable, w zasadzie.

00:14:18.085 --> 00:14:19.750
Więc wszystko, co możesz
zrobić, aby IEnumerator,

00:14:19.750 --> 00:14:21.355
można to zrobić do IObservable.

00:14:21.355 --> 00:14:23.410
Tak to było jak pamiętam
gdy link po raz pierwszy przyszedł

00:14:23.410 --> 00:14:25.990
i wszyscy byli
super podekscytowany

00:14:25.990 --> 00:14:28.225
Link jak link przez obiekty i

00:14:28.225 --> 00:14:31.510
Link do SQL, a następnie były one
mniej podekscytowany link do SQL,

00:14:31.510 --> 00:14:33.800
ale link był tak ekscytujący.

00:14:36.960 --> 00:14:41.260
Tak skutecznie masz
pobrane dane, które jest następny, onNext.

00:14:41.260 --> 00:14:44.650
Tak jak każdy z Twoich danych
punktów.

00:14:44.650 --> 00:14:47.920
To, gdzie zatrzymuje się w miarę, gdzie

00:14:47.920 --> 00:14:52.030
Observables stają się bardziej
ekscytujące niż wydarzenia.

00:14:52.030 --> 00:14:54.550
Więc dostajesz te inne rzeczy.

00:14:54.550 --> 00:14:56.875
Więc masz na przykład powietrze.

00:14:56.875 --> 00:15:02.770
Jeśli wydarzenie, w którym jesteś
Obserwacja manifestuje wyjątek,

00:15:02.770 --> 00:15:05.800
można sobie z tym poradzić,
część obserwowalnych.

00:15:05.800 --> 00:15:09.340
Dlatego w ramach przepływu danych
operacji można wskazać,

00:15:09.340 --> 00:15:12.970
Hej tam to wydarzenie
przez wyjątek.

00:15:12.970 --> 00:15:14.515
Na przykład żądanie sieci Web.

00:15:14.515 --> 00:15:16.990
Jeśli występuje żądanie sieci Web i

00:15:16.990 --> 00:15:20.020
zgłasza wyjątek, ponieważ

00:15:20.020 --> 00:15:22.165
Internet idzie w dół lub
coś podobnego do tego,

00:15:22.165 --> 00:15:24.850
następnie można skutecznie złapać, że

00:15:24.850 --> 00:15:28.645
i radzić sobie z tym
w ramach tej konstrukcji.

00:15:28.645 --> 00:15:29.920
Więc to sprawia, że kod dużo

00:15:29.920 --> 00:15:35.695
bardziej wytrzymałe, a następnie
również uzyskać ten pomysł

00:15:35.695 --> 00:15:39.760
zakończenia, gdzie można strzelać,

00:15:39.760 --> 00:15:43.345
ktoś wskazał, że

00:15:43.345 --> 00:15:45.790
już nie obchodzi
o punktach danych,

00:15:45.790 --> 00:15:47.725
następnie można działać na tym.

00:15:47.725 --> 00:15:50.590
Wszystkie te rzeczy
stają się cechami

00:15:50.590 --> 00:15:54.070
sposób interakcji z danymi.

00:15:54.070 --> 00:16:01.760
Więc oto kilka
punktów porównawczych.

00:16:06.120 --> 00:16:09.070
Więc to jest również zaczerpany z ReactiveX.

00:16:09.070 --> 00:16:13.030
Jak można zobaczyć tutaj, masz
Iterable który jest Twój upływ,

00:16:13.030 --> 00:16:14.890
tak to jest jak Twój IEnumerator i

00:16:14.890 --> 00:16:16.860
masz rację, które
jest Twój IObservable.

00:16:16.860 --> 00:16:19.150
Więc jeden jest uzyskanie danych
z pamięci lokalnej,

00:16:19.150 --> 00:16:20.210
tak to będzie być może jak

00:16:20.210 --> 00:16:21.890
operacji synchronicznej, w której po prostu

00:16:21.890 --> 00:16:23.870
Twoje dane są realizowane w

00:16:23.870 --> 00:16:26.240
góry i masz rację
jeden jest z sieci,

00:16:26.240 --> 00:16:29.580
może to być wolniejsze strumieniowe źródło danych.

00:16:29.580 --> 00:16:32.915
Tak więc, można zobaczyć
masz te same pomysły

00:16:32.915 --> 00:16:37.350
strumieni zdarzeń, które
jest po prostu, jest super-potężny.

00:16:37.870 --> 00:16:42.940
Miłe rzeczy. W porządku.

00:16:42.940 --> 00:16:45.450
Załóżmy, że rozbić

00:16:45.450 --> 00:16:48.610
bloków konstrukcyjnych
IObservables trochę tutaj.

00:16:50.010 --> 00:16:54.250
Jest to więc podstawowa idea
Jak budować IObservable.

00:16:54.250 --> 00:16:57.205
Tak jak widzisz w
że pierwszy krok tam,

00:16:57.205 --> 00:17:01.940
widzisz znajomy Subskrybuj
i zrezygnować z subskrypcji,

00:17:03.840 --> 00:17:07.450
to nie jest takie ekscytujące,
to po prostu przechodzi przez

00:17:07.450 --> 00:17:10.390
różne funkcje obserwatora,

00:17:10.390 --> 00:17:11.830
więc obserwator wie, jak radzić sobie

00:17:11.830 --> 00:17:14.185
z subskrypcjami i unsubscribes,

00:17:14.185 --> 00:17:18.250
tak, że może on konteneryzują, że
zachowanie w IObservable.

00:17:18.250 --> 00:17:26.185
Więc tutaj jest porównawcza
wersje tych,

00:17:26.185 --> 00:17:29.515
tego, co reprezentują.

00:17:29.515 --> 00:17:34.690
Więc Subskrybuj jest skutecznie
powołując się na ten Top facet,

00:17:34.690 --> 00:17:37.840
jeden górny kliknięty
i powiedzenie: "OK,

00:17:37.840 --> 00:17:40.090
teraz dbam o moje wydarzenia ", a następnie

00:17:40.090 --> 00:17:43.000
na dole tam
jest teraz utylizacja,

00:17:43.000 --> 00:17:45.715
który jest następnie anulowanie subskrypcji.

00:17:45.715 --> 00:17:48.730
To jest, gdzie zaczyna
Aby uzyskać naprawdę potężny,

00:17:48.730 --> 00:17:54.535
ponieważ masz
cała ta reprezentacja

00:17:54.535 --> 00:17:58.210
jest hermetyzowany w znanym wzorze.

00:17:58.210 --> 00:18:01.810
Więc masz IDisposable
którego wszyscy użyliśmy,

00:18:01.810 --> 00:18:10.080
i mamy logiczne struktury danych

00:18:10.080 --> 00:18:11.310
i sposobów, które możemy wykorzystać

00:18:11.310 --> 00:18:14.760
skuteczniej niż
tylko powiedzieć, anulowanie subskrypcji.

00:18:14.760 --> 00:18:18.700
Więc niektóre naprawdę fajne
sposobów, które można zrobić,

00:18:18.700 --> 00:18:20.680
można łatwo zarządzać
tych czasów życia.

00:18:20.680 --> 00:18:25.359
Więc pamiętaj, zanim
Aby upewnić się, że zrezygnujesz z subskrypcji,

00:18:25.359 --> 00:18:28.600
tak jak w formularzach Xamarin na przykład

00:18:28.600 --> 00:18:32.590
Jeśli zmieniasz element
lub jeśli coś nowego przychodzi

00:18:32.590 --> 00:18:34.210
w którym chcesz subskrybować

00:18:34.210 --> 00:18:36.325
i nie obchodzi mnie
już stare rzeczy,

00:18:36.325 --> 00:18:40.000
musisz zrobić to coś, gdzie
wypisać się ze starego,

00:18:40.000 --> 00:18:41.290
Zapisz się na nowy,

00:18:41.290 --> 00:18:44.920
a następnie punkt zbycia

00:18:44.920 --> 00:18:48.955
, aby upewnić się, że nie subskrybujesz
również z tych wydarzeń.

00:18:48.955 --> 00:18:50.650
Więc to jest miłe jednak,

00:18:50.650 --> 00:18:57.070
jest to, że całe wydarzenie
System zarządzania obserwacją

00:18:57.070 --> 00:19:00.055
mogą być przegubowe
poprzez jednorazowe.

00:19:00.055 --> 00:19:02.740
Działamy na to i wiele
z tych rzeczy tutaj

00:19:02.740 --> 00:19:05.215
Życzę, by po prostu wyciągnąć
w the.Net Framework,

00:19:05.215 --> 00:19:08.290
ale teraz, w

00:19:08.290 --> 00:19:11.440
ReactiveX masz te rzeczy
jak CompositeDisposable.

00:19:11.440 --> 00:19:13.450
Więc idea jest
można agregować

00:19:13.450 --> 00:19:17.035
wszystkie swoje jednorazowe
jednolitej struktury danych,

00:19:17.035 --> 00:19:20.260
a następnie, że struktura danych teraz,

00:19:20.260 --> 00:19:22.225
można po prostu wyrzucić raz,

00:19:22.225 --> 00:19:26.125
po upływie okresu
Klasa zawierająca znika,

00:19:26.125 --> 00:19:28.540
i teraz wszystkie wydarzenia
zarządzania opieką.

00:19:28.540 --> 00:19:33.310
Możesz więc załączyć
PropertyChanged subskrypcje,

00:19:33.310 --> 00:19:37.570
subskrypcji TextChanged,
a potem po prostu wyrzucić.

00:19:37.570 --> 00:19:38.650
Więc to miłe, bo dostajesz

00:19:38.650 --> 00:19:44.200
te pojęcia obiektów, które
Możesz ubiegać się o swoje wydarzenia,

00:19:44.200 --> 00:19:48.740
więc to miłe, Lubię to.

00:19:51.900 --> 00:19:55.030
Na przykład, jak byłem
mówić o wcześniej,

00:19:55.030 --> 00:19:57.430
gdzie masz instancję

00:19:57.430 --> 00:19:59.725
gdzie masz stary element
subskrybowanego,

00:19:59.725 --> 00:20:01.000
Chodzi mi o nowy element

00:20:01.000 --> 00:20:04.690
w ten sposób nie obchodzi Cię
już stary.

00:20:04.690 --> 00:20:06.310
Tak to ma jak te fajne pojęcia

00:20:06.310 --> 00:20:08.110
tu z jak seryjny utylizacji,

00:20:08.110 --> 00:20:09.910
gdzie wszystko, co
przypisać do tego będzie

00:20:09.910 --> 00:20:12.250
Automatycznie usuwaj
rzeczy przed nim.

00:20:12.250 --> 00:20:14.980
Więc w tych pomysłów tutaj,

00:20:14.980 --> 00:20:16.900
nie musisz

00:20:16.900 --> 00:20:19.690
wypisać się za to, co przyszedł
tam, co jest naprawdę miłe.

00:20:19.690 --> 00:20:23.530
Ale wiesz, że jest to
Nowy hotness, który Ci zależy,

00:20:23.530 --> 00:20:25.390
i wtedy, gdy przychodzi,

00:20:25.390 --> 00:20:28.735
po prostu pozbyć się
cokolwiek tam było,

00:20:28.735 --> 00:20:30.370
Tak więc, że pozwala na ustawienie

00:20:30.370 --> 00:20:36.470
te naprawdę fajne wyrażenia
co chcesz zrobić.

00:20:37.320 --> 00:20:41.770
Ponieważ wiele rzeczy z
Reaktywny, który jest naprawdę miły,

00:20:41.770 --> 00:20:47.560
jest posiadanie wszystkich intencji
w jednym miejscu.

00:20:47.560 --> 00:20:51.050
Zarządzanie zdarzeniami jest
bardzo oparte na zwrotnym,

00:20:52.080 --> 00:20:56.320
nie dostaniesz w złych stylach
jak całkowite piekło oddzwaniania,

00:20:56.320 --> 00:20:58.645
ale to wciąż miłe
tej samej rzeczy.

00:20:58.645 --> 00:21:01.330
To zarządzanie zwrotnym
a następnie interakcję

00:21:01.330 --> 00:21:03.760
wszystkie te różne wywołania zwrotne
scenariuszach, gdy

00:21:03.760 --> 00:21:06.665
to samo z tym, w jaki sposób
zarządzać okresem jego istnienia.

00:21:06.665 --> 00:21:13.470
Ale ma ktoś tutaj zrobione
Xamarin Forms rzeczy?

00:21:13.470 --> 00:21:17.050
Jestem tylko mapowanie
logiczne modelings tutaj.

00:21:17.050 --> 00:21:20.455
Więc masz ten pomysł teraz, gdzie

00:21:20.455 --> 00:21:25.690
sposób, w jaki można

00:21:25.690 --> 00:21:27.250
zarządzanie całym cyklem życia

00:21:27.250 --> 00:21:30.635
coś jest po prostu dobrze
w tej części środkowej,

00:21:30.635 --> 00:21:33.840
i to wszystko, co musisz zrobić.

00:21:33.840 --> 00:21:36.315
Po skonfigurowaniu tam,

00:21:36.315 --> 00:21:40.635
teraz w każdej chwili Przyjdź i
masz zmianę elementu,

00:21:40.635 --> 00:21:42.650
i zależy Ci tylko
o nowym elemencie,

00:21:42.650 --> 00:21:47.230
Przypisywanie nowych przyczyn jednorazowych
poprzedniego do usunięcia,

00:21:47.230 --> 00:21:49.990
więc teraz wszystkie wydarzenia
są całkowicie nieprzewodowe,

00:21:49.990 --> 00:21:52.645
i teraz zaczynasz
okablowanie nowych.

00:21:52.645 --> 00:21:53.860
Następnie w swoim wyrzucone,

00:21:53.860 --> 00:21:56.260
po prostu masz jeden
seryjny Dispose, który jest

00:21:56.260 --> 00:22:01.750
zasób zarządzany na poziomie klasy
że jesteś utylizacji.

00:22:01.750 --> 00:22:06.880
Więc teraz nie ma

00:22:06.880 --> 00:22:10.480
tego stopnia złożoności zarządzania
zakresie obsługi.

00:22:10.480 --> 00:22:13.300
Więc to rzeczywiście było
Pierwszą rzeczą, która mnie do

00:22:13.300 --> 00:22:17.630
Programowanie reaktywne było
Zarządzanie jednorazowe,

00:22:18.900 --> 00:22:22.150
Myślę, że to było jak rok przed
Ja bym nawet kiedyś cokolwiek innego.

00:22:22.150 --> 00:22:25.540
Tylko dlatego, że miałem Silverlight
aplikacji, która miała

00:22:25.540 --> 00:22:30.775
Niektóre problemy z subskrypcją i
wtedy zdarzyło mi się na tych rzeczy,

00:22:30.775 --> 00:22:32.815
więc te rzeczy są fajne,

00:22:32.815 --> 00:22:34.870
jednorazowego użytku sprawiają, że jestem bardzo szczęśliwy.

00:22:34.870 --> 00:22:37.390
Tak więc są one nadal mapowanie niektórych

00:22:37.390 --> 00:22:40.120
te idee, które są
naprawdę schludny, tak jak tutaj,

00:22:40.120 --> 00:22:42.700
pamiętać przed
chciał tylko subskrybować

00:22:42.700 --> 00:22:45.445
że jedno wydarzenie i tylko
chciał zobaczyć go raz?

00:22:45.445 --> 00:22:48.640
Z reaktywne, można zrobić

00:22:48.640 --> 00:22:52.045
że cała koncepcja tutaj
z tym jednym wyrazem.

00:22:52.045 --> 00:22:54.160
Więc wszystko to mówi,

00:22:54.160 --> 00:22:58.839
"Chcę tylko jedną wartość z
tej właściwości zmienione,

00:22:58.839 --> 00:23:02.680
a następnie w tym punkcie I
chcesz go pozbyć. "

00:23:02.680 --> 00:23:05.335
Więc mam na myśli to niesamowite, prawda,

00:23:05.335 --> 00:23:07.555
Weź jeden, a następnie przełączyć,

00:23:07.555 --> 00:23:10.180
który jest trochę trudny do
zrozumieć, ale te są

00:23:10.180 --> 00:23:13.270
tylko tyle powodów
używać go na zawsze,

00:23:13.270 --> 00:23:15.340
to miłe, Lubię to.

00:23:15.340 --> 00:23:22.210
Tak to jest podział
działania.

00:23:22.210 --> 00:23:31.670
Więc mam kilka demek
Zdając sobie sprawę z tego w kodzie nieco więcej,

00:23:33.360 --> 00:23:39.970
ale chciałem dać jakąś koncepcję
Prep do Ciebie, jak również,

00:23:39.970 --> 00:23:45.700
do niektórych typów reaktywnych
struktur, z których korzystasz,

00:23:45.700 --> 00:23:47.980
tak to sprawia, że trochę więcej sensu.

00:23:47.980 --> 00:23:50.500
Więc jeden ze sposobów opisać rzeczy

00:23:50.500 --> 00:23:53.185
z reaktywną jest
za pomocą diagramów marmuru,

00:23:53.185 --> 00:23:55.075
więc są te idee widząc

00:23:55.075 --> 00:24:01.405
dane wejściowe i dane wyjściowe.

00:24:01.405 --> 00:24:03.760
Więc dwa górne tutaj,

00:24:03.760 --> 00:24:10.285
jest to vernacular dla
najbardziej reaktywne informacje,

00:24:10.285 --> 00:24:14.800
więc zawsze widzisz
Operatory reaktywne opisane,

00:24:14.800 --> 00:24:16.330
są one zawsze opisane
w tym formacie.

00:24:16.330 --> 00:24:19.810
Więc idea jest taka, że
dwie najważniejsze rzeczy to strumienie danych,

00:24:19.810 --> 00:24:23.480
a następnie dolny jest
co widzi Twój abonent.

00:24:24.420 --> 00:24:27.519
Scalanie będzie dwóch subskrybentów,

00:24:27.519 --> 00:24:29.980
tak jak gdyby subskrybując
powiedzieć zdarzenie TextChanged

00:24:29.980 --> 00:24:36.175
w polu nazwy użytkownika i
pole hasła, na przykład,

00:24:36.175 --> 00:24:38.620
w każdej chwili albo
tych zmian jest

00:24:38.620 --> 00:24:40.690
jak wyglądałby Twój wynik.

00:24:40.690 --> 00:24:43.360
Więc są to jedne z
operatorów użyłem w demo,

00:24:43.360 --> 00:24:44.620
więc chciałem tylko

00:24:44.620 --> 00:24:50.350
, aby upewnić się, że
zrozumiałem przed przeniesieniem.

00:24:50.350 --> 00:24:53.350
Więc Filter, to jest
w zasadzie jak gdzie,

00:24:53.350 --> 00:24:57.460
tak na link do IEnumerable,

00:24:57.460 --> 00:25:00.280
to tak jak gdzie.

00:25:00.280 --> 00:25:02.260
Tak skutecznie każde wydarzenie, które przychodzi

00:25:02.260 --> 00:25:05.810
na tyle proste, aby zrozumieć.

00:25:05.850 --> 00:25:09.100
Debunu, więc jest to
inne naprawdę fajne funkcji,

00:25:09.100 --> 00:25:11.395
tak to jest ograniczanie danych wejściowych.

00:25:11.395 --> 00:25:13.570
Więc w tym przykładzie, co oni

00:25:13.570 --> 00:25:16.210
demonstracji jest
że chcą tylko

00:25:16.210 --> 00:25:17.710
najnowszej wartości

00:25:17.710 --> 00:25:21.025
po pewnym
określonym czasie.

00:25:21.025 --> 00:25:25.840
Więc widać, że jest lag
pomiędzy jedną a piątą, ponieważ dwa,

00:25:25.840 --> 00:25:27.745
trzy, a cztery są

00:25:27.745 --> 00:25:30.280
dzieje się tak blisko siebie
że pięć jest obecnie wychodzi.

00:25:30.280 --> 00:25:33.910
Tak więc jest to najistotniej
przykład dla reaktywnych rzeczy,

00:25:33.910 --> 00:25:36.850
przypadków, w których użytkownicy

00:25:36.850 --> 00:25:39.400
robi jak Szukaj z

00:25:39.400 --> 00:25:42.305
Google, gdy wpisujesz
w ich autouzupełniania,

00:25:42.305 --> 00:25:45.220
ale nie chcesz jak kick
żądania sieci Web za każdym razem,

00:25:45.220 --> 00:25:48.640
tak to skutecznie, co
to pokazuje,

00:25:48.640 --> 00:25:50.305
których mamy przykład.

00:25:50.305 --> 00:25:56.640
Następnie TakeUntil jest
ostatniego operatora, którego używam,

00:25:56.640 --> 00:25:58.110
więc TakeUntil jest naprawdę schludny,

00:25:58.110 --> 00:26:01.170
ponieważ jest to na przykład
wyglądać jak żądanie sieci Web.

00:26:01.170 --> 00:26:04.605
Załóżmy, że żądanie sieci Web
jest Kicking off,

00:26:04.605 --> 00:26:07.210
a następnie użytkownik
zaczyna pisać ponownie,

00:26:07.210 --> 00:26:09.880
lub mówią anulować,

00:26:09.880 --> 00:26:11.560
jak nie chcą
to się już wydarzyło,

00:26:11.560 --> 00:26:16.360
więc wszystkie te są inne
punkty zdarzeń, które można podjąć,

00:26:16.360 --> 00:26:19.465
i w tym momencie tnie
już od strumienia.

00:26:19.465 --> 00:26:22.375
Tak to jest jak naprawdę
prosty sposób powiedzieć odcięte,

00:26:22.375 --> 00:26:25.940
Jeśli nie chcesz, aby żądanie sieci Web
lub coś takiego do końca.

00:26:25.940 --> 00:26:32.400
Tak to jest podział
obserwowalnych rzeczy,

00:26:32.400 --> 00:26:35.470
Więc pozwól mi przejść,

00:26:36.080 --> 00:26:39.380
przytrzymaj jedną sekundę.

00:26:39.380 --> 00:26:52.660
Cool, zobaczmy.

00:26:53.540 --> 00:26:55.875
Czy to jest zbyt małe?

00:26:55.875 --> 00:26:57.610
>> tak.

00:26:58.710 --> 00:27:01.330
>> To jest rzeczy, które
zrobić, gdy zdajesz sobie sprawę

00:27:01.330 --> 00:27:04.000
że nigdy nie robiłeś
tych na dema przed,

00:27:04.000 --> 00:27:07.525
Faktycznie nigdy nie wzrosła
jego rozmiar czcionki na obs Mac przed.

00:27:07.525 --> 00:27:16.300
Zobaczmy. Staram się
czynić mój Windows rzeczy tutaj,

00:27:16.300 --> 00:27:20.540
nie pójdziemy, Zgaduję, że to jest to.

00:27:22.580 --> 00:27:26.610
Wszystko w porządku ja był trudny u
Moje gesty na podkładce.

00:27:26.610 --> 00:27:27.630
Zrobiłem machnięcia.

00:27:27.630 --> 00:27:28.650
Zrobiłem dwa palce,

00:27:28.650 --> 00:27:32.670
Zrobiłem to. Nie wiem.

00:27:32.670 --> 00:27:35.280
Nie zdarzyło mi się na to chyba.

00:27:35.280 --> 00:27:45.015
Więc nie pójdziemy. Dobra tak.

00:27:45.015 --> 00:27:46.740
Tak jak uruchomić Windows
gdzie po prostu uderzyć

00:27:46.740 --> 00:27:48.615
sterowania i dzielenia.

00:27:48.615 --> 00:27:51.910
Wszystko w porządku, aby wszyscy
może to zobaczyć. W porządku?

00:27:52.070 --> 00:27:55.410
Więc pozwól mi uruchomić demo prawdziwe

00:27:55.410 --> 00:27:59.895
szybkie tylko tak mamy kontekst
tego, co robimy tutaj.

00:27:59.895 --> 00:28:02.640
Więc jest to rodzaj
podstawową aplikację.

00:28:02.640 --> 00:28:08.355
To tylko idea wylogowania logowania.

00:28:08.355 --> 00:28:14.265
tak, więc poniżej mam zestaw
zdarzeń, które mają miejsce,

00:28:14.265 --> 00:28:21.690
więc to jest skutecznie
strumienia danych obserwables.

00:28:21.690 --> 00:28:23.970
Więc wszystkie zdarzenia, które są
dzieje się z obserwables.

00:28:23.970 --> 00:28:25.365
Więc tutaj mamy zalogować.

00:28:25.365 --> 00:28:27.240
Więc to jest użytkownik i hasło

00:28:27.240 --> 00:28:28.665
że powinienem umieć
dziennika symboli zastępczych.

00:28:28.665 --> 00:28:34.095
Ale pomysł tutaj
puszka metalowa zobaczyć jeśli JA uderzyć pewien pismo.

00:28:34.095 --> 00:28:36.509
Nie. Więc hit list

00:28:36.509 --> 00:28:39.090
i w tym momencie jest
sprawdzania poprawności danych wejściowych.

00:28:39.090 --> 00:28:41.175
Teraz widać, że
istnieje rodzaj tego opóźnienia.

00:28:41.175 --> 00:28:43.935
Prawo? Więc jeśli uderzyć
"O" jest opóźnienie.

00:28:43.935 --> 00:28:46.170
Więc idea za
oznacza to, że jesteś

00:28:46.170 --> 00:28:49.455
nie-to, że odbijanie
że mówisz.

00:28:49.455 --> 00:28:54.945
Więc jeśli wpisuja w "username"
i "hasło".

00:28:54.945 --> 00:28:59.310
Nie. Widać, że raz
tego sprawdzania poprawności się dzieje.

00:28:59.310 --> 00:29:01.710
Więc to tylko my rodzaj przerwy
tych struktur po tym, jak

00:29:01.710 --> 00:29:04.275
dostać tam, ale to
idei.

00:29:04.275 --> 00:29:08.910
Więc. Tak. Tak bardzo ekscytujące.

00:29:08.910 --> 00:29:11.955
Teraz mamy symulowane do logowania.

00:29:11.955 --> 00:29:14.250
Więc pomysł tutaj klikam "login".

00:29:14.250 --> 00:29:18.840
Uruchamia żądanie sieci Web, a następnie
w tym momencie można się wylogować.

00:29:18.840 --> 00:29:21.870
Więc i nie ma rodzaju

00:29:21.870 --> 00:29:26.415
dodatkowe Zobaczmy, ile razy
to trwa przed tym wyzwala.

00:29:26.415 --> 00:29:30.090
Więc mam Randomizer
tam losowo

00:29:30.090 --> 00:29:35.415
generować błędy. To jest.

00:29:35.415 --> 00:29:38.400
Cool. Więc można zobaczyć tutaj, co

00:29:38.400 --> 00:29:41.775
Zdarza się, że
kliknięciu przycisku "login".

00:29:41.775 --> 00:29:44.535
Wygenerował wyjątek.

00:29:44.535 --> 00:29:47.895
Tak jak wyjątek żądania sieci Web.

00:29:47.895 --> 00:29:51.630
Wtedy powiedziałem dobrze, niech tylko
Ponów próbę żądania sieci Web.

00:29:51.630 --> 00:29:59.640
Następnie w tym momencie
następnie zalogowany do mnie, prawda?

00:29:59.640 --> 00:30:02.655
Następnie inny aspekt
tego, co mnie.

00:30:02.655 --> 00:30:05.070
Jak Załóżmy, że użytkownik
chce go anulować.

00:30:05.070 --> 00:30:09.100
Więc jeśli klikają "login"
mogą kliknąć przycisk "Anuluj".

00:30:09.350 --> 00:30:13.470
Tam można zobaczyć teraz to nie
przetwarzania danych.

00:30:13.470 --> 00:30:16.035
Prawo? Dlatego, że

00:30:16.035 --> 00:30:18.885
istnieje rodzaj operacji
anulowania.

00:30:18.885 --> 00:30:23.805
Więc to jest demo.

00:30:23.805 --> 00:30:25.815
tak, więc to jest idea.

00:30:25.815 --> 00:30:27.900
Jest to kod.

00:30:27.900 --> 00:30:32.160
tak, więc idea

00:30:32.160 --> 00:30:34.965
za tym do rodzaju
rozbicie struktur.

00:30:34.965 --> 00:30:37.935
Ponieważ Wszyscy widzieliśmy wiele
z tych rzeczy jest to, że

00:30:37.935 --> 00:30:41.340
to jest łatwość
aspekt obserwables.

00:30:41.340 --> 00:30:43.890
Aspekt możliwości do opanowania
jest to, że masz

00:30:43.890 --> 00:30:46.920
reprezentowanie Twoich wydarzeń

00:30:46.920 --> 00:30:50.730
tych pojedynczych strumieni danych
można następnie rozpocząć

00:30:50.730 --> 00:30:55.845
Intermix do wyrażania
zachowanie aplikacji.

00:30:55.845 --> 00:31:01.050
Więc jeśli mamy aplikację, co
Wszystkie strumienie zdarzeń tutaj.

00:31:01.050 --> 00:31:03.360
Strumienie zdarzeń są
Mamy wpis na

00:31:03.360 --> 00:31:07.065
na górze mamy wpis
na drugim polu.

00:31:07.065 --> 00:31:10.320
Jako typy użytkowników mamy
Kliknij przycisk logowania.

00:31:10.320 --> 00:31:12.975
Mamy przycisk Anuluj kliknij
i mamy jak Web Request.

00:31:12.975 --> 00:31:17.205
Tak więc skutecznie
pięć różnych zdarzeń.

00:31:17.205 --> 00:31:20.550
Strumienie, które musimy opisać.

00:31:20.550 --> 00:31:28.545
Możemy więc przełamać te
do ich części reaktywnych.

00:31:28.545 --> 00:31:32.145
Więc te są całkiem unexciting.

00:31:32.145 --> 00:31:37.050
To takie same rzeczy, które
widział, co jest w zasadzie

00:31:37.050 --> 00:31:39.180
just powiedzenie hej ja potrzeba wobec wierzyciel ten

00:31:39.180 --> 00:31:42.630
obserwowalne, że słucha
do klikniętego zdarzenia.

00:31:42.630 --> 00:31:46.095
Więc jest to podstawowy aspekt
tego, co jest ekscytujące.

00:31:46.095 --> 00:31:51.825
Dlatego tworzymy obserwowalne
każdego z tych różnych elementów.

00:31:51.825 --> 00:31:54.030
Mamy nasz login.

00:31:54.030 --> 00:31:55.470
Więc to po kliknięciu.

00:31:55.470 --> 00:31:56.805
Mamy nasze wylogowanie.

00:31:56.805 --> 00:31:58.440
Wtedy się wylogują.

00:31:58.440 --> 00:32:01.785
Mamy nasze anulowanie. Czyli
Po kliknięciu przycisku "Anuluj".

00:32:01.785 --> 00:32:06.750
Mamy zmianę tekstu
tu, co jest, gdy są one

00:32:06.750 --> 00:32:09.000
wpisując nazwę użytkownika i mamy

00:32:09.000 --> 00:32:12.090
Hasło, gdy są one
wpisując hasło.

00:32:12.090 --> 00:32:15.300
Następnie robimy
fałszywe wywołanie żądania sieci Web.

00:32:15.300 --> 00:32:17.670
Więc to jest tylko wykazanie.

00:32:17.670 --> 00:32:20.565
Jest to zasadniczo po prostu
czekać dwie sekundy.

00:32:20.565 --> 00:32:22.440
Następnie po jego zakończeniu generuje

00:32:22.440 --> 00:32:26.265
błąd, jeśli niektóre losowe
liczba jest równa dwóch.

00:32:26.265 --> 00:32:35.010
Tak. Więc to jest nasza aplikacja.

00:32:35.010 --> 00:32:38.250
To w obserwowalnych
Reprezentacja

00:32:38.250 --> 00:32:41.985
wszystkie zdarzenia, które mogą wystąpić
w aplikacji, prawda?

00:32:41.985 --> 00:32:43.860
Więc teraz jest to, gdzie

00:32:43.860 --> 00:32:47.680
aspekt możliwości do opanowania
do gry, która jest naprawdę cool.

00:32:48.500 --> 00:32:51.150
Teraz wszystkie te
różne obserwables

00:32:51.150 --> 00:32:53.220
własne życie.

00:32:53.220 --> 00:33:00.060
Tak więc całość
logikę, którą widzisz

00:33:00.060 --> 00:33:06.990
jest zawarte z dość
prosta ilość kodu, prawda?

00:33:06.990 --> 00:33:12.780
Więc tutaj jest to nasz kod weryfikacyjny.

00:33:12.780 --> 00:33:14.940
Więc teraz to, co robimy, to
Budujemy

00:33:14.940 --> 00:33:18.810
dodatkowe obserwables na
tych innych obserwables.

00:33:18.810 --> 00:33:21.990
Prawo? Więc to jest to, co
aspekt możliwości jej opanowania.

00:33:21.990 --> 00:33:23.640
Więc pierwszym z nich jest

00:33:23.640 --> 00:33:26.520
mówią dobrze, że chcemy
uwierzytelnione obserwowalne.

00:33:26.520 --> 00:33:29.580
Uwierzytelniony obserwowalny
jest użytkownik, klikając

00:33:29.580 --> 00:33:33.060
"Login" i kliknięcie
"żądanie sieci Web".

00:33:33.060 --> 00:33:39.090
Więc teraz stworzyliśmy te dwa
pomysłów na obserwowalne wydarzenia.

00:33:39.090 --> 00:33:42.870
Teraz połączymy te dane
strumień z wylogowania.

00:33:42.870 --> 00:33:47.250
Więc jeśli użytkownik kliknie "Wyloguj"
to mówi: "Hej,

00:33:47.250 --> 00:33:48.735
Chcę się wylogować. "

00:33:48.735 --> 00:33:54.480
Mamy więc cały
stan uwierzytelniania

00:33:54.480 --> 00:34:00.525
wniosek reprezentowany przez
Nowy zauważalny uwierzytelniony.

00:34:00.525 --> 00:34:02.295
Uwierzytelniony obserwowalny.

00:34:02.295 --> 00:34:05.295
Więc to jedyne zauważalne
Dbamy o to w tym momencie.

00:34:05.295 --> 00:34:07.530
Tak więc teraz możemy użyć tego

00:34:07.530 --> 00:34:09.540
gdziekolwiek indziej, gdzie

00:34:09.540 --> 00:34:14.940
chcesz zapytać o to, co jest
użytkownik uwierzytelniony.

00:34:14.940 --> 00:34:18.190
Wiesz, co jest potrzebne.

00:34:19.910 --> 00:34:22.620
Wtedy mamy naszą walidację.

00:34:22.620 --> 00:34:24.720
Walidacja jest składem

00:34:24.720 --> 00:34:29.410
Nasza nazwa użytkownika i hasło
tam, co jest miłe.

00:34:29.570 --> 00:34:33.645
Tak, że w istocie przychodzi.

00:34:33.645 --> 00:34:35.894
Mówi "Hej,

00:34:35.894 --> 00:34:38.909
są to punkty danych
które reprezentują ważność. "

00:34:38.909 --> 00:34:43.080
Przekształca te zdarzenia w

00:34:43.080 --> 00:34:47.910
prawdziwej lub fałszywej wartości,
może teraz użyć do powiedzenia: "OK.

00:34:47.910 --> 00:34:53.860
Jaki jest stan wydarzeń
które zostały w najbliższych? "

00:34:55.190 --> 00:34:58.515
Więc to niech nas teraz

00:34:58.515 --> 00:35:01.455
złączyć-teraz możemy umieścić
wszystkie te rzeczy razem.

00:35:01.455 --> 00:35:03.120
To jest, gdzie rodzaj
jak funkcjonalne

00:35:03.120 --> 00:35:05.295
aspekt programowania reaktywnego
wchodzi w grę.

00:35:05.295 --> 00:35:08.880
Możemy teraz umieścić wszystkie te różne
obserwables razem w

00:35:08.880 --> 00:35:10.485
jedno ładne małe miejsce

00:35:10.485 --> 00:35:15.255
tutaj, który opisuje wszystko
to się dzieje.

00:35:15.255 --> 00:35:17.760
Jest to więc część
to jest naprawdę miłe.

00:35:17.760 --> 00:35:22.995
Ponieważ z tym
aplikacji można uzyskać

00:35:22.995 --> 00:35:27.120
zakres perspektywy na wszystkich

00:35:27.120 --> 00:35:31.710
logikę tylko przez prawo
tutaj w tym punkcie kodu.

00:35:31.710 --> 00:35:36.060
Nie ma konieczności
skakać lub cokolwiek.

00:35:36.060 --> 00:35:40.170
Jest to niezmienna lokalizacja oparta na

00:35:40.170 --> 00:35:46.485
niezmienne dane do zmodyfikowania
sposób działania tych punktów danych.

00:35:46.485 --> 00:35:50.190
Więc to jest miłe, ponieważ
to miły łatwy sposób.

00:35:50.190 --> 00:35:53.490
Tak jak dane, które przychodzi
w tej wartości wynik tutaj

00:35:53.490 --> 00:35:57.450
jest strukturą niezmienialny.

00:35:57.450 --> 00:36:00.435
Następnie na podstawie tych danych
znać uwierzytelniony dostrzegalny.

00:36:00.435 --> 00:36:02.760
Więc co to robi
tu jest powiedzenie co '

00:36:02.760 --> 00:36:06.315
stan uwierzytelniania jest, czy
Jesteś uwierzytelniony lub nie.

00:36:06.315 --> 00:36:10.845
Ważne jest powiedzenie, czy
poświadczenia, które wprowadzono jako ważne.

00:36:10.845 --> 00:36:12.360
Następnie na podstawie tego,

00:36:12.360 --> 00:36:17.320
ustawiasz widoczność
aplikacji.

00:36:20.170 --> 00:36:22.890
tak, więc można skonfigurować
jak widoczność

00:36:22.890 --> 00:36:26.200
aplikacji. Więc to miłe.

00:36:28.340 --> 00:36:31.905
Zobaczmy więc.

00:36:31.905 --> 00:36:34.350
Mam jeszcze jeden demo Real szybkie,

00:36:34.350 --> 00:36:36.820
tylko jeden mały.

00:36:39.350 --> 00:36:43.725
Oops, trochę za duży
nie. Nie idziemy.

00:36:43.725 --> 00:36:45.345
Czy wszyscy widzą, że w porządku?

00:36:45.345 --> 00:36:50.400
Tak. W porządku. Mam te
jak repozytoria GitHub.

00:36:50.400 --> 00:36:53.520
To za pomocą trochę
reaktywnych rzeczy UI,

00:36:53.520 --> 00:36:55.695
ale pozwól mi tylko pokazać.

00:36:55.695 --> 00:37:00.730
Ma kilka różnych próbek
, które można przyjrzeć.

00:37:02.360 --> 00:37:10.240
Mam nadzieję, że to działa. Czy jest to
już działa? Tam to idzie.

00:37:10.940 --> 00:37:14.980
Tak wiele z nich jest
prostych rzeczy, które widzisz.

00:37:15.050 --> 00:37:17.775
Spójrzmy na
demo pozycji, ponieważ jesteśmy

00:37:17.775 --> 00:37:19.905
czas pracy jest niski.

00:37:19.905 --> 00:37:21.900
Więc idea demo pozycji

00:37:21.900 --> 00:37:24.810
jest to, że jesteś śledzenia
wskaźnika myszy.

00:37:24.810 --> 00:37:30.780
Ma to inny popularny przykład
dla koncepcji reaktywnych.

00:37:30.780 --> 00:37:32.055
Więc naciskać.

00:37:32.055 --> 00:37:33.660
To wykrywanie, naciśnij.

00:37:33.660 --> 00:37:34.740
Jeśli poruszasz myszą,

00:37:34.740 --> 00:37:36.000
teraz to wykrywa, że przeniósł się,

00:37:36.000 --> 00:37:37.380
a potem puścić, i daje

00:37:37.380 --> 00:37:40.335
agregację wszystkich danych.

00:37:40.335 --> 00:37:49.380
To rozbite trochę

00:37:49.380 --> 00:37:51.720
bo muszę mieć
opisy,

00:37:51.720 --> 00:37:56.080
ale to naprawdę miłe, ponieważ
wszystko, co musisz naprawdę zrobić,

00:37:56.120 --> 00:37:58.905
masz wskaźnik naciśnięcia zdarzenia.

00:37:58.905 --> 00:38:01.200
Więc masz wskaźnik
Prasa, która mówi,

00:38:01.200 --> 00:38:03.840
"Hej, nacisnął mysz w dół."

00:38:03.840 --> 00:38:06.840
Teraz, gdy to ma
się wydarzyło, mówisz: "OK,

00:38:06.840 --> 00:38:10.395
Chcę subskrybować
wskaźnik jest przesuwany wokół. "

00:38:10.395 --> 00:38:14.170
Więc jest to teraz wskaźnik
przemieszczać się wokół.

00:38:14.240 --> 00:38:16.800
Jak to się porusza teraz,

00:38:16.800 --> 00:38:20.085
wyciągasz wszystkie te dane
razem,

00:38:20.085 --> 00:38:23.145
a następnie dwa operator listy, tutaj,

00:38:23.145 --> 00:38:24.960
jest teraz w stanie
zagregowane wszystkie te dane

00:38:24.960 --> 00:38:27.405
razem w jeden zestaw danych.

00:38:27.405 --> 00:38:29.760
Następnie tutaj, aż do

00:38:29.760 --> 00:38:32.220
jedną operację, która
Pokazaliśmy tutaj.

00:38:32.220 --> 00:38:34.170
Mówi: "Hej, dobrze,
Chcę tylko, aby

00:38:34.170 --> 00:38:36.270
dane i poinformować
wskaźniki zwolnione. "

00:38:36.270 --> 00:38:38.309
Więc masz to naprawdę
fajne interakcje

00:38:38.309 --> 00:38:40.020
wszystkich tych wydarzeń do powiedzenia,

00:38:40.020 --> 00:38:41.940
bo wszystko, co naprawdę chciał
powiedzieć, że chcę przenieść

00:38:41.940 --> 00:38:44.130
myszy wokół i kiedy
puścić myszką,

00:38:44.130 --> 00:38:45.810
Chcę wszystkie dane, które tam było.

00:38:45.810 --> 00:38:47.160
Więc można dostać wszystko to

00:38:47.160 --> 00:38:50.505
reprezentowane w tej miłej
Mały subskrypcja tutaj.

00:38:50.505 --> 00:38:55.120
Więc jest to jeden z
tych głównych przykładów.

00:38:57.130 --> 00:39:03.360
Tak, to jest szybki podkład
w koncepcje reaktywne.

00:39:04.690 --> 00:39:08.940
Istnieje wiele
dobre ramy.

00:39:11.210 --> 00:39:16.740
Oops, nie pomocne. Nie idziemy.

00:39:16.740 --> 00:39:23.280
Tak. Więc to jest idea za
Większość obserwables.

00:39:23.280 --> 00:39:25.530
Michael będzie rozmawiać
nieco więcej o używaniu

00:39:25.530 --> 00:39:28.545
tych struktur z MVVM.

00:39:28.545 --> 00:39:32.880
Jest wiele naprawdę potężnych
narzędzi, takich jak dane dynamiczne.

00:39:32.880 --> 00:39:35.100
Wybierz dane dynamiczne,

00:39:35.100 --> 00:39:37.590
naprawdę fajna platforma

00:39:37.590 --> 00:39:41.985
dla supermocarstwo na listach
z obserwables.

00:39:41.985 --> 00:39:43.890
Więc chodzi o to, że można

00:39:43.890 --> 00:39:46.995
zasadniczo sprawiają, że
wszystko i dostrzegalne.

00:39:46.995 --> 00:39:49.660
Możesz go podpisać,
Nie wiedziałem o tym.

00:39:51.470 --> 00:39:53.610
Więc myślę, że prawdziwe szybkie,

00:39:53.610 --> 00:39:55.960
Czy ktoś ma pytania?

00:39:57.410 --> 00:40:00.720
Tak, sam. Cóż, tak.

00:40:00.720 --> 00:40:04.095
Będziemy Let's just iść tam. Będziemy
pytania kilka 35 minut.

00:40:04.095 --> 00:40:05.520
>> Więc rozmawiać o

00:40:05.520 --> 00:40:10.380
ujawniając
[niesłyszalny] i wszystkie te rzeczy.

00:40:10.380 --> 00:40:14.220
Dyskusja o tym, dlaczego obserwables
są lepsze [niesłyszalne].

00:40:14.220 --> 00:40:20.460
>> tak, więc

00:40:20.460 --> 00:40:24.045
chyba powiedziałbym, bo
zarządzania-więc pytanie było,

00:40:24.045 --> 00:40:25.680
z przeciekającego pamięci,

00:40:25.680 --> 00:40:28.290
Dlaczego jest fakt, że zwraca

00:40:28.290 --> 00:40:31.245
jednorazowy lepszy pierwszy
powiedzieć zarządzanie pamięcią?

00:40:31.245 --> 00:40:33.090
Idea jest po prostu, tak,

00:40:33.090 --> 00:40:37.230
to jest fakt, że
jego żywotność

00:40:37.230 --> 00:40:43.665
obserwowalny jest aspekt
subskrypcji.

00:40:43.665 --> 00:40:46.920
Więc gdy subskrybujesz
do niego wrócić,

00:40:46.920 --> 00:40:49.395
ponieważ w każdej chwili otrzymasz
jednorazowy od czegoś,

00:40:49.395 --> 00:40:51.270
wiesz, że masz
utylizacji.

00:40:51.270 --> 00:40:54.630
Jak to jest paradygmat, którego używamy.

00:40:54.630 --> 00:40:57.060
Więc to jest idea o tym.

00:40:57.060 --> 00:41:01.365
To, że z odpowietrzania
zwłaszcza dla nowych programistów,

00:41:01.365 --> 00:41:03.660
zawsze będą
sprawiają, że jako błąd

00:41:03.660 --> 00:41:07.700
gdzie są jak coś

00:41:07.700 --> 00:41:08.810
zamiar przeżyć coś innego

00:41:08.810 --> 00:41:10.250
bo trzeba to zrozumieć.

00:41:10.250 --> 00:41:15.360
Ale jednorazowe jest
bardzo podstawową koncepcją.

00:41:15.360 --> 00:41:19.155
Tak więc, że jako część
subskrypcji

00:41:19.155 --> 00:41:22.860
sprawia, że zarządzanie pamięcią
scenariuszy.

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

00:41:25.440 --> 00:41:26.940
Inne pytania?

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

00:41:28.727 --> 00:41:35.250
>> [niesłyszalny].

00:41:35.250 --> 00:41:39.060
>> tak. Więc pytanie było,

00:41:39.060 --> 00:41:41.985
można użyć reaktywne programowanie

00:41:41.985 --> 00:41:45.060
z takimi zadaniami lub
Programowanie asynchroniczne?

00:41:45.060 --> 00:41:50.865
Tak. Tak więc zadanie jest skutecznie
powiadomienie o jednym punkcie.

00:41:50.865 --> 00:41:53.355
Więc gdy masz zadanie,

00:41:53.355 --> 00:41:57.210
Istnieją trzy punkty danych dla
zadanie, które jest dokładnie takie jak

00:41:57.210 --> 00:42:02.175
naszych iteratora, gdy byliśmy wskazując.

00:42:02.175 --> 00:42:05.040
Więc kiedy piszesz zadanie-OK,

00:42:05.040 --> 00:42:06.615
Nie wiem, gdzie jest
zbliża się. W porządku.

00:42:06.615 --> 00:42:08.190
Więc gdy masz zadanie,

00:42:08.190 --> 00:42:14.145
utworzeniu zadania, tak aby
masz go na początku,

00:42:14.145 --> 00:42:19.724
następnie uruchom zadanie
więc teraz jest uruchomiony,

00:42:19.724 --> 00:42:23.355
a następnie zadanie tworzy wartość,

00:42:23.355 --> 00:42:26.445
to Twoje wyniki dot
których nikt z nas nie pisze,

00:42:26.445 --> 00:42:29.970
a następnie kończy na
ukończenie tego.

00:42:29.970 --> 00:42:31.440
Więc w tym momencie,

00:42:31.440 --> 00:42:35.190
masz jeden punkt danych obserwowalny.

00:42:35.190 --> 00:42:40.680
Więc jednorazowe tworzy rzeczy

00:42:40.680 --> 00:42:42.900
które działają dokładnie przeciwko zadaniu,

00:42:42.900 --> 00:42:45.180
można utworzyć
obserwowalne w stosunku do zadania.

00:42:45.180 --> 00:42:49.125
Tak więc, co się stanie, gdy
zapisać się do obserwowalnych,

00:42:49.125 --> 00:42:54.494
Czy to będzie skutecznie uruchomić zadanie
i wtedy, gdy to nastąpi,

00:42:54.494 --> 00:42:56.190
że kopie wyników.

00:42:56.190 --> 00:42:59.655
Tak, że produkuje jedną wartość
a następnie kończy.

00:42:59.655 --> 00:43:01.410
To kolejna rzecz
to naprawdę super

00:43:01.410 --> 00:43:03.600
pomocne, ponieważ jeśli to zadanie nie powiedzie się,

00:43:03.600 --> 00:43:05.040
dostajesz swoje rzeczy z

00:43:05.040 --> 00:43:07.485
obserwables, gdzie
może przechwycić wyjątek.

00:43:07.485 --> 00:43:13.500
Na przykład scenariusze
jak Async void, na przykład.

00:43:13.500 --> 00:43:16.575
Asynchroniczne void jest bez problemu
z obserwables.

00:43:16.575 --> 00:43:18.495
Nigdy nie musisz się martwić o

00:43:18.495 --> 00:43:21.970
Async void Jeśli jesteś
obserwables.

00:43:22.040 --> 00:43:26.520
Na przykład, wiesz, jak
może chcesz uruchomić zadanie asynchroniczne

00:43:26.520 --> 00:43:28.050
z konstruktora lub rzeczy, takich jak

00:43:28.050 --> 00:43:30.060
że lub te kwestie z
osób z obserwables,

00:43:30.060 --> 00:43:31.200
to nawet nie scenariusz,

00:43:31.200 --> 00:43:34.320
bo po prostu owinąć zadanie w

00:43:34.320 --> 00:43:36.180
obserwowalne, a następnie

00:43:36.180 --> 00:43:39.225
zachowanie wyjątków jako część
obserwowalnych z zadaniem.

00:43:39.225 --> 00:43:40.710
Więc tak, pracują.

00:43:40.710 --> 00:43:42.060
Doskonale nadaje się do wykonywania zadań.

00:43:42.060 --> 00:43:43.770
Więc nie zapominam, kto mówi.

00:43:43.770 --> 00:43:46.260
Jeffrey czy coś podobnego
że nie mówić o tym;

00:43:46.260 --> 00:43:48.015
mówienie o tym, jak zadania są

00:43:48.015 --> 00:43:50.010
Super źle i powinieneś
Wystarczy użyć observables.

00:43:50.010 --> 00:43:51.360
Ale tak, po rozpoczęciu korzystania

00:43:51.360 --> 00:43:53.685
obserwables, zwłaszcza
w kodzie interfejsu użytkownika,

00:43:53.685 --> 00:43:55.260
będziesz skutecznie po prostu umieścić

00:43:55.260 --> 00:43:57.420
elewacji przed wszystkimi
zadań, ponieważ

00:43:57.420 --> 00:44:02.080
staje się o wiele prostsze do
zarządzać poprzez obserwables.

00:44:02.450 --> 00:44:04.905
Inne pytania?

00:44:04.905 --> 00:44:07.840
I'm getting Shhh.

00:44:09.380 --> 00:44:12.870
Czy mogę wziąć jeszcze jedno
Pytanie? Nr? Dobra, nie.

00:44:12.870 --> 00:44:15.075
Odpowiemy na Twoje
pytanie zaraz po.

00:44:15.075 --> 00:44:17.340
Cool. Więc tak, jestem Shane.

00:44:17.340 --> 00:44:20.500
To moje obserwables.