WEBVTT

00:00:00.000 --> 00:00:03.190
[ ] 好的。你好。
大家都好嗎？

00:00:03.380 --> 00:00:08.280
第四到通過的方式
我們的Xam峰會在這裡。

00:00:08.280 --> 00:00:12.870
所以,是的,我是謝恩
諾伊維爾拼寫正確？

00:00:12.870 --> 00:00:17.715
是的。謝恩·諾伊維爾我
與Xamarin形式團隊。

00:00:17.715 --> 00:00:20.280
在加入 Xamarin 表單之前,

00:00:20.280 --> 00:00:23.490
我工作相當多
與反應UI。

00:00:23.490 --> 00:00:26.160
所以我仍然試圖捍衛
和我一樣多

00:00:26.160 --> 00:00:29.310
甚至可以從微軟內部。

00:00:29.310 --> 00:00:35.970
所以這裡的談話將是
大量關於反應擴展,

00:00:35.970 --> 00:00:39.990
特別是只是概念
在磁碟機反應後,

00:00:39.990 --> 00:00:42.990
他們如何接近事件。

00:00:42.990 --> 00:00:44.975
然後,邁克爾要做

00:00:44.975 --> 00:00:47.600
更廣泛的談話
映射出來像

00:00:47.600 --> 00:00:52.040
MVVM 和如何供電
您的框架。

00:00:52.040 --> 00:00:56.055
所以讓我們開始這個,

00:00:56.055 --> 00:00:59.305
有多少人使用過
反應擴展,

00:00:59.305 --> 00:01:01.350
只是為了得到,"哦,嘿。很好。

00:01:01.350 --> 00:01:02.895
每次我問
有更多的手

00:01:02.895 --> 00:01:08.040
所以這是一個好兆頭。我看看。

00:01:08.040 --> 00:01:12.250
有多少人認為我在說話
關於JavaScript和反應JS？

00:01:12.250 --> 00:01:15.250
那邊的那個人,他？好吧。

00:01:16.130 --> 00:01:20.150
所以一些方言
開始清除以及。

00:01:20.150 --> 00:01:23.450
有人認為我會
談論可觀察的集合

00:01:23.450 --> 00:01:26.940
大約一個小時？不。好吧。

00:01:26.940 --> 00:01:29.990
因此,沿著這個框架

00:01:29.990 --> 00:01:33.530
變得少一點
相關,因為會談進行。

00:01:33.530 --> 00:01:37.580
肯定有
一些混亂,開始。

00:01:37.580 --> 00:01:39.980
所以我記得第一個
時間,我聽到反應。

00:01:39.980 --> 00:01:42.955
我做RxJS已經有一段時間了

00:01:42.955 --> 00:01:45.380
大約五分鐘
進入談話,

00:01:45.380 --> 00:01:48.695
我意識到我們沒有
相同的談話。

00:01:48.695 --> 00:01:51.890
所以沒有真正的

00:01:51.890 --> 00:01:55.920
任何關係,除了
前五個字母。

00:01:57.410 --> 00:02:01.105
角已啟動
大量使用 RxJS。

00:02:01.105 --> 00:02:03.260
所以角可能是
更多同義字

00:02:03.260 --> 00:02:05.870
在這一點上與RxJS,但是的。

00:02:05.870 --> 00:02:08.810
然後,下一個區域
在那裡人們被拋出

00:02:08.810 --> 00:02:12.305
關閉有做
反應X和反應性UI,

00:02:12.305 --> 00:02:14.345
以及這些劃分點的位置。

00:02:14.345 --> 00:02:21.810
所以反應X是
與平臺無關的概念。

00:02:21.810 --> 00:02:25.760
因此,反應X概念

00:02:25.760 --> 00:02:28.940
跨
多個框架。

00:02:28.940 --> 00:02:35.390
所以有一個可哥,一個JAVA,RxJS。

00:02:35.390 --> 00:02:40.515
有一大堆語言
實現這些概念。

00:02:40.515 --> 00:02:45.090
然後,反應UI是 MVVM 層

00:02:45.090 --> 00:02:48.750
説明插入反應X
到您的 MVVM。

00:02:48.750 --> 00:02:52.905
所以當人們
談論反應,

00:02:52.905 --> 00:02:54.705
他們不只是在說話
關於反應性UI。

00:02:54.705 --> 00:02:55.820
他們主要在談論

00:02:55.820 --> 00:02:59.090
功能反應程式設計和

00:02:59.090 --> 00:03:02.810
可觀察性如何
程式設計範例工作。

00:03:02.810 --> 00:03:05.870
因此,反應X方面是

00:03:05.870 --> 00:03:10.655
主要是這個談話是什麼
會繞轉

00:03:10.655 --> 00:03:15.245
這將是一個很好的前兆
邁克爾的談話後。

00:03:15.245 --> 00:03:18.830
那為什麼它向我發出蜂鳴聲？

00:03:18.830 --> 00:03:20.240
堅持。我可能
也許我沒有

00:03:20.240 --> 00:03:22.845
強調。我們開始吧。

00:03:22.845 --> 00:03:29.300
因此,讓我們打破什麼
我們真的在看這裡

00:03:29.300 --> 00:03:32.420
因此,讓我們來談談
事件真的很快。

00:03:32.420 --> 00:03:35.570
那麼,你如何訂閱
事件？都是很基本的

00:03:35.570 --> 00:03:37.945
我們以前都見過這個代碼。

00:03:37.945 --> 00:03:41.190
給你。很興奮,對吧？

00:03:41.190 --> 00:03:46.085
如此有效地,你有
你的出版商在左邊。

00:03:46.085 --> 00:03:48.260
你有你的活動
然後你有

00:03:48.260 --> 00:03:50.990
你的觀察者就在那兒

00:03:50.990 --> 00:03:57.230
所以,這是一個基本事件
通知模式,

00:03:57.230 --> 00:03:58.760
你的基本觀察者模式。

00:03:58.760 --> 00:04:02.030
這就是 C# 中的語法。

00:04:02.030 --> 00:04:04.190
有效地,頂部
一個人做同樣的事情

00:04:04.190 --> 00:04:06.395
作為底部,但句法糖。

00:04:06.395 --> 00:04:10.725
因此,讓我們來分解一下什麼是事件。

00:04:10.725 --> 00:04:14.005
所以一個事件本質上是,

00:04:14.005 --> 00:04:21.095
這是一系列個人的事情
生成資料。

00:04:21.095 --> 00:04:25.260
所以,如果我輸入我的名字,

00:04:25.990 --> 00:04:29.930
我鍵入 S,有
事件,h 和事件,

00:04:29.930 --> 00:04:33.635
一個和事件,我想你看
這些都到哪裡去了

00:04:33.635 --> 00:04:39.080
和表示
資料在這裡。

00:04:39.080 --> 00:04:41.990
因此,這是一組具有

00:04:41.990 --> 00:04:46.325
基於這些事件發生。

00:04:46.325 --> 00:04:49.220
所以,這是你的事件。

00:04:49.220 --> 00:04:51.455
所以沒有什麼太令人振奮的
在這一點上。

00:04:51.455 --> 00:04:55.340
因此,停止觀察事件的步驟。

00:04:55.340 --> 00:04:58.000
那麼,你如何停止
觀察事件？

00:04:58.000 --> 00:05:00.600
我們都未被觀察到
前場活動,對吧？

00:05:00.600 --> 00:05:01.760
就像我們說的,"嘿,我沒有

00:05:01.760 --> 00:05:03.620
長期關心什麼
這件事發生。

00:05:03.620 --> 00:05:08.960
所以通常,過程
找出如何

00:05:08.960 --> 00:05:11.720
取消訂閱事件啟動

00:05:11.720 --> 00:05:15.155
與客戶抱怨
應用速度慢。

00:05:15.155 --> 00:05:19.070
因此,客戶檔
一個問題,並說,"嘿,

00:05:19.070 --> 00:05:21.840
我的應用程式在使用它後速度變慢。

00:05:22.670 --> 00:05:24.690
出什麼事了？

00:05:24.690 --> 00:05:27.075
我用的越多
它不工作。

00:05:27.075 --> 00:05:30.550
首先,你不相信他們。

00:05:31.400 --> 00:05:35.090
你認為他們
安裝的東西,如

00:05:35.090 --> 00:05:37.730
迪爾伯特螢幕保護裝置程式,正在採取

00:05:37.730 --> 00:05:39.980
打開整個瀏覽器視窗
或類似的東西。

00:05:39.980 --> 00:05:42.290
因為當你開始
你的應用程式和

00:05:42.290 --> 00:05:44.795
你使用它
大約15秒,它很快。

00:05:44.795 --> 00:05:46.895
一切都工作正常。
反應靈敏。

00:05:46.895 --> 00:05:51.670
你已經發現它很完美了

00:05:51.670 --> 00:05:54.435
那麼,你會說,"所有
對。我想我相信他們。

00:05:54.435 --> 00:05:58.530
所以在這一點上,你塵土
摘下你的調試帽

00:05:58.530 --> 00:06:01.110
重新閱讀所有
測試和博客如何

00:06:01.110 --> 00:06:04.185
分析堆疊幀,

00:06:04.185 --> 00:06:06.675
你開始把一切都拉了

00:06:06.675 --> 00:06:08.145
您得到堆疊 DOM。

00:06:08.145 --> 00:06:10.925
你看看多久
物件是活的。

00:06:10.925 --> 00:06:13.055
你一遍又一遍地做。

00:06:13.055 --> 00:06:15.740
最後,你下來了。

00:06:15.740 --> 00:06:18.290
有很多凝視
箭頭指向事物,

00:06:18.290 --> 00:06:19.940
想知道什麼物體重要,

00:06:19.940 --> 00:06:22.280
並減去這
從那直到你

00:06:22.280 --> 00:06:23.900
終於看到有

00:06:23.900 --> 00:06:25.595
是一行代碼或
你忘了寫

00:06:25.595 --> 00:06:27.990
你就像"哦,夥計"
然後,突然之間,

00:06:27.990 --> 00:06:30.195
一切都開始運行超快。

00:06:30.195 --> 00:06:33.699
所以,是的,我的意思是,基本上,

00:06:35.210 --> 00:06:38.280
訂閱和取消訂閱它們。

00:06:38.280 --> 00:06:43.980
這就是它的語義。

00:06:43.980 --> 00:06:48.345
但語義,這是
我覺得有點小雅。

00:06:48.345 --> 00:06:52.655
因為一個,你必須
記得做兩件事。

00:06:52.655 --> 00:06:55.130
任何時候我必須記住
做不止一件事

00:06:55.130 --> 00:06:57.850
你會失敗
通常在程式設計中。

00:06:57.850 --> 00:07:00.695
此外,您必須保留
你對一切的引用。

00:07:00.695 --> 00:07:04.040
所以為了做重要的
第二個,

00:07:04.040 --> 00:07:05.210
你需要一切

00:07:05.210 --> 00:07:08.125
你的第一個做
你第二個的一切

00:07:08.125 --> 00:07:11.930
就像你必須
保持這些想法。

00:07:11.930 --> 00:07:16.725
因此,在一般事件管理
只是,太亂了

00:07:16.725 --> 00:07:20.015
它不是最乾淨的類型
操作。

00:07:20.015 --> 00:07:21.290
我是說,就像我們說的

00:07:21.290 --> 00:07:26.600
你只關心
單個事件,例如,

00:07:26.600 --> 00:07:28.465
就像我們都編寫了這個代碼一樣

00:07:28.465 --> 00:07:31.340
如果你想
取消訂閱類似

00:07:31.340 --> 00:07:35.600
你只是想解雇一個

00:07:35.600 --> 00:07:38.915
所以,讓我們說,像一個出現頁面
或那種性質的東西,

00:07:38.915 --> 00:07:42.140
所以你必須有
頂部的參考

00:07:42.140 --> 00:07:45.830
使關閉
裡面有訪問它,

00:07:45.830 --> 00:07:47.975
然後分配處理常式,

00:07:47.975 --> 00:07:50.255
然後你做
末尾的處理常式。

00:07:50.255 --> 00:07:55.280
所以有這個連續的儀式

00:07:55.280 --> 00:07:59.150
來自
一組操作。

00:07:59.150 --> 00:08:03.050
所以這看起來很熟悉。是
以前每個人都寫過這個代碼？

00:08:03.050 --> 00:08:05.790
是的？好吧。

00:08:06.930 --> 00:08:12.655
所以,在這裡,我仍然
談論事件。

00:08:12.655 --> 00:08:14.860
這就是我所說的
可觀察資訊商業。

00:08:14.860 --> 00:08:16.360
你在哪裡做某事
瘋狂,你就像

00:08:16.360 --> 00:08:17.680
"哦,我的上帝,它是如此可怕。

00:08:17.680 --> 00:08:22.135
沒那麼糟糕但在這裡
我指示所有的東西。

00:08:22.135 --> 00:08:24.115
這不是Xamarin表格

00:08:24.115 --> 00:08:26.725
當你接線到一個事件。

00:08:26.725 --> 00:08:29.485
所以你連線到事件,

00:08:29.485 --> 00:08:32.425
你必須找到好
我的處置方面在哪裡？

00:08:32.425 --> 00:08:33.835
好了,就在這裡

00:08:33.835 --> 00:08:37.330
我必須確保
從事件處置和

00:08:37.330 --> 00:08:41.350
所有這些東西是完全不同的
整個檔中的位置。

00:08:41.350 --> 00:08:42.730
這些都是所有這些事情。

00:08:42.730 --> 00:08:44.290
這個儀式你必須做

00:08:44.290 --> 00:08:46.240
與所有這些事件
管理系統。

00:08:46.240 --> 00:08:48.790
往上看,你
必須訂閱它。

00:08:48.790 --> 00:08:51.385
然後,您有您的處理常式在這裡。

00:08:51.385 --> 00:08:52.810
您正在處理

00:08:52.810 --> 00:08:55.180
一個單獨的點和
然後在這裡彎曲。

00:08:55.180 --> 00:08:59.635
非常
斷開連接的經驗。

00:08:59.635 --> 00:09:01.240
所以在這裡,我甚至鍵入
錯誤的事情,

00:09:01.240 --> 00:09:03.625
我是如此慌亂,它是多麼困難。

00:09:03.625 --> 00:09:07.720
但是,是的。所以我得到了資訊商
汽水去哪了？

00:09:07.720 --> 00:09:13.225
這就是問題。

00:09:13.225 --> 00:09:18.175
所以事件是這些奇異的
同步資料點。

00:09:18.175 --> 00:09:20.650
因此,您將獲得文本變更事件

00:09:20.650 --> 00:09:22.690
然後你擁有的所有
文本變更事件。

00:09:22.690 --> 00:09:24.460
你只有那封信
你只要有那封信

00:09:24.460 --> 00:09:27.195
s,你必須處理。

00:09:27.195 --> 00:09:29.145
但是如果你想
更多嗎？

00:09:29.145 --> 00:09:31.200
如果,因為每當
你有個事件

00:09:31.200 --> 00:09:33.840
你很少關心
關於一個事件。

00:09:33.840 --> 00:09:36.680
您關心資料
一組事件。

00:09:36.680 --> 00:09:37.870
你關心一切

00:09:37.870 --> 00:09:40.510
發生在一段時間內。

00:09:40.510 --> 00:09:43.750
所以如果你想做
非常令人興奮的東西。

00:09:43.750 --> 00:09:45.220
所以如果你想說

00:09:45.220 --> 00:09:47.590
跳過你的前五個事件,

00:09:47.590 --> 00:09:50.050
那就只關心接下來的四個

00:09:50.050 --> 00:09:52.015
然後你想破壞事件,

00:09:52.015 --> 00:09:56.139
所以,如果他們鍵入超快
只等兩秒鐘

00:09:56.139 --> 00:09:57.610
然後,讓我們說,你想過濾掉

00:09:57.610 --> 00:09:59.215
任何事件是玉米花藍色

00:09:59.215 --> 00:10:02.545
只是因為它是一個可怕的顏色
可能,我不知道。

00:10:02.545 --> 00:10:05.110
然後你想

00:10:05.110 --> 00:10:07.120
啟動 Web 請求
然後他們重新開始

00:10:07.120 --> 00:10:08.860
所以你想把它扔掉

00:10:08.860 --> 00:10:12.220
像這樣的模式是

00:10:12.220 --> 00:10:16.900
很常見,至於
您的活動管理,

00:10:16.900 --> 00:10:22.630
特別是在 MVVM 框架和
更基於 UI 的東西。

00:10:22.630 --> 00:10:25.420
你總是要做出反應

00:10:25.420 --> 00:10:29.830
對傳入資料點
與連接丟失。

00:10:29.830 --> 00:10:31.240
所以喜歡如果
您的連接獲取

00:10:31.240 --> 00:10:33.460
丟失在網路請求點？

00:10:33.460 --> 00:10:34.870
你如何中斷

00:10:34.870 --> 00:10:39.745
該網路請求一次
連接丟失？

00:10:39.745 --> 00:10:48.460
你如何以可靠的方式做到這一點
很容易管理。

00:10:48.460 --> 00:10:50.680
因此,所有這些概念都有

00:10:50.680 --> 00:10:58.060
動詞的很清楚版本
映射他們在反應。

00:10:58.060 --> 00:10:59.830
所以這些都是
實際的東西,你可以

00:10:59.830 --> 00:11:02.590
使用反應表達

00:11:02.590 --> 00:11:07.795
所有這些對您的資料的嘗試,

00:11:07.795 --> 00:11:09.880
年事件流。

00:11:09.880 --> 00:11:13.720
好吧。那麼還有什麼
我們能處理事件嗎？

00:11:13.720 --> 00:11:19.010
不是真的那麼多。
非常簡單的基本模式。

00:11:19.260 --> 00:11:23.725
這就是我對事件的拆解。

00:11:23.725 --> 00:11:26.110
所以在這一點上,如果
你還沒有真正使用

00:11:26.110 --> 00:11:28.450
反應性,你大概像,
"哦,我一直如此糟糕。

00:11:28.450 --> 00:11:31.600
我一直做錯了
所有的時間,"你有

00:11:31.600 --> 00:11:33.610
一個存在危機約

00:11:33.610 --> 00:11:37.970
所有的問題,你沒有
知道你有,現在你有。

00:11:39.900 --> 00:11:45.580
因此,讓我們翻譯這
到可觀察的。

00:11:45.580 --> 00:11:48.370
因此,我觀察一直
周圍一段時間。

00:11:48.370 --> 00:11:49.660
它本質上就像

00:11:49.660 --> 00:11:52.855
發佈訂閱模型

00:11:52.855 --> 00:11:55.900
這是核心
框架of.Net和

00:11:55.900 --> 00:11:59.005
然後反應X是更多的

00:11:59.005 --> 00:12:04.465
如何交互的運算式
與那些可觀察的。

00:12:04.465 --> 00:12:11.245
因此,讓我們打破什麼
可觀察的就在這裡。

00:12:11.245 --> 00:12:15.020
因此,它本質上是
觀察者模式。

00:12:18.690 --> 00:12:21.790
從根本上說,它是
和事件一樣

00:12:21.790 --> 00:12:26.000
事件是有效的
觀察者模式。

00:12:27.420 --> 00:12:30.775
所以,你有你的活動在這裡,

00:12:30.775 --> 00:12:34.449
處理常式和發行者

00:12:34.449 --> 00:12:37.870
然後,這是類似的
到這裡。

00:12:37.870 --> 00:12:42.865
所以,你有你的可觀察
那是在看,

00:12:42.865 --> 00:12:45.070
它做同樣的事情。

00:12:45.070 --> 00:12:47.980
所以你也有同樣的想法。

00:12:47.980 --> 00:12:51.220
有效地,你可以做確切的
同樣的事情與這兩個在

00:12:51.220 --> 00:12:54.925
基礎層和
獲取資料點。

00:12:54.925 --> 00:12:56.650
但現在令人興奮的事情

00:12:56.650 --> 00:12:58.285
所以這是令人興奮的點

00:12:58.285 --> 00:13:00.620
一切都開始發揮作用。

00:13:03.690 --> 00:13:07.540
與事件,你不
真的有什麼。

00:13:07.540 --> 00:13:09.385
你只有一個事件。

00:13:09.385 --> 00:13:11.770
但現在有了一個可觀察的,

00:13:11.770 --> 00:13:13.510
你有一個表示
該事件。

00:13:13.510 --> 00:13:17.095
您實際上具有類似資料物件
你可以做事情。

00:13:17.095 --> 00:13:22.645
所以這是區別
之間有一個專案從

00:13:22.645 --> 00:13:25.360
清單,而不是

00:13:25.360 --> 00:13:28.675
說整個名單
你現在可以操作過來。

00:13:28.675 --> 00:13:32.140
所以,這是你的
差異開始發揮作用。

00:13:32.140 --> 00:13:35.590
所以,你可以想到
可觀察非常多

00:13:35.590 --> 00:13:39.550
作為反覆運算器模式。

00:13:39.550 --> 00:13:42.340
因此,這是從反應性x。Io

00:13:42.340 --> 00:13:44.485
這是主要來源之一,

00:13:44.485 --> 00:13:45.520
這是一個非常好的來源。

00:13:45.520 --> 00:13:48.100
它有一個細目
所有操作員和一切。

00:13:48.100 --> 00:13:49.930
所以我有一個連結,它在那裡
在底部為你。

00:13:49.930 --> 00:13:56.605
是的,它有效地映射

00:13:56.605 --> 00:14:02.170
你可觀察到的想法

00:14:02.170 --> 00:14:03.925
同樣的事情,你可以
做一個反覆運算器。

00:14:03.925 --> 00:14:05.635
幾乎有一個完美的

00:14:05.635 --> 00:14:08.560
一對一比較
在那裡,當你反覆運算。

00:14:08.560 --> 00:14:11.605
因此,反覆運算器就像 IEnumerator。

00:14:11.605 --> 00:14:13.945
等同的

00:14:13.945 --> 00:14:18.085
IEnumerator 是等效物
基本上,我可觀察。

00:14:18.085 --> 00:14:19.750
所以任何你能
做一個IE數位,

00:14:19.750 --> 00:14:21.355
你可以做到這一點,以一個可觀察。

00:14:21.355 --> 00:14:23.410
就像記得
當連結第一次來

00:14:23.410 --> 00:14:25.990
出,每個人都是
超級興奮

00:14:25.990 --> 00:14:28.225
連結,如連結的物件和

00:14:28.225 --> 00:14:31.510
連結到 SQL,然後他們
不太興奮連結到 SQL,

00:14:31.510 --> 00:14:33.800
但林克是如此令人興奮。

00:14:36.960 --> 00:14:41.260
因此,有效地,你有你的
檢索到的資料,這是下一步,Next。

00:14:41.260 --> 00:14:44.650
因此,作為您的每個資料
點來通過。

00:14:44.650 --> 00:14:47.920
這是它停止到哪兒

00:14:47.920 --> 00:14:52.030
可觀測到的更多
令人興奮的比你的事件。

00:14:52.030 --> 00:14:54.550
所以,你得到這些其他的東西。

00:14:54.550 --> 00:14:56.875
所以,你得到空氣,例如。

00:14:56.875 --> 00:15:02.770
如果你的活動,你
觀察出現異常,

00:15:02.770 --> 00:15:05.800
你可以處理,作為
可觀察的一部分。

00:15:05.800 --> 00:15:09.340
因此,作為資料流程的一部分
操作,你可以指出,

00:15:09.340 --> 00:15:12.970
嘿,有這個事件
通過異常。

00:15:12.970 --> 00:15:14.515
例如,Web 請求。

00:15:14.515 --> 00:15:16.990
如果發生 Web 請求,並且

00:15:16.990 --> 00:15:20.020
引發異常,因為

00:15:20.020 --> 00:15:22.165
互聯網下降或
類似的東西,

00:15:22.165 --> 00:15:24.850
然後你可以有效地趕上

00:15:24.850 --> 00:15:28.645
並處理
在該構造中。

00:15:28.645 --> 00:15:29.920
因此,它使您的代碼很多

00:15:29.920 --> 00:15:35.695
更健壯,然後你
也得到這個想法

00:15:35.695 --> 00:15:39.760
完成,你可以發射,如果

00:15:39.760 --> 00:15:43.345
有人表示

00:15:43.345 --> 00:15:45.790
他們不再關心
關於資料點,

00:15:45.790 --> 00:15:47.725
然後,你可以採取行動。

00:15:47.725 --> 00:15:50.590
所有這些東西
成為功能

00:15:50.590 --> 00:15:54.070
如何與資料交互。

00:15:54.070 --> 00:16:01.760
所以這裡還有一些
比較點。

00:16:06.120 --> 00:16:09.070
因此,這也取自反應X。

00:16:09.070 --> 00:16:13.030
正如您在這裡看到的,您有
可反覆運算,這是你的失誤,

00:16:13.030 --> 00:16:14.890
所以這就像你的IE統計器和

00:16:14.890 --> 00:16:16.860
你是對的
是你的可觀察的

00:16:16.860 --> 00:16:19.150
因此,一個是獲取資料
從本地記憶體,

00:16:19.150 --> 00:16:20.210
所以,這將是也許像一個

00:16:20.210 --> 00:16:21.890
同步操作,你只是

00:16:21.890 --> 00:16:23.870
實現您的資料

00:16:23.870 --> 00:16:26.240
頂部,你是正確的
一個來自網路,

00:16:26.240 --> 00:16:29.580
可能是較慢的資料摘要。

00:16:29.580 --> 00:16:32.915
所以在那裡,你可以看到
你得到這些相同的想法

00:16:32.915 --> 00:16:37.350
在你的事件流
只是,它是超級強大的。

00:16:37.870 --> 00:16:42.940
整潔的東西。好吧。

00:16:42.940 --> 00:16:45.450
讓我們來分解一下

00:16:45.450 --> 00:16:48.610
構建塊
你的可觀察性在這裡位。

00:16:50.010 --> 00:16:54.250
因此,這是基本的想法
你如何建立可觀察的。

00:16:54.250 --> 00:16:57.205
所以,正如你在
第一步

00:16:57.205 --> 00:17:01.940
你看到熟悉的訂閱
並取消訂閱,

00:17:03.840 --> 00:17:07.450
沒太激動人心了
它只是通過

00:17:07.450 --> 00:17:10.390
不同的功能,觀察員,

00:17:10.390 --> 00:17:11.830
所以觀察者知道如何處理

00:17:11.830 --> 00:17:14.185
訂閱和取消訂閱,

00:17:14.185 --> 00:17:18.250
以便它可以容器化,
I 可觀察行為。

00:17:18.250 --> 00:17:26.185
這裡是比較
這些版本,

00:17:26.185 --> 00:17:29.515
這些代表什麼。

00:17:29.515 --> 00:17:34.690
因此,訂閱是有效的
援引那個頂級人物

00:17:34.690 --> 00:17:37.840
頂部一個點擊
說,"好吧,

00:17:37.840 --> 00:17:40.090
現在,我關心我的事件,"然後

00:17:40.090 --> 00:17:43.000
底部有
正在處置,

00:17:43.000 --> 00:17:45.715
然後取消訂閱。

00:17:45.715 --> 00:17:48.730
這是它開始的地方
變得非常強大,

00:17:48.730 --> 00:17:54.535
因為你有
這整個代表

00:17:54.535 --> 00:17:58.210
封裝在熟悉的模式中。

00:17:58.210 --> 00:18:01.810
所以你有我
我們都用過

00:18:01.810 --> 00:18:10.080
我們有邏輯資料結構

00:18:10.080 --> 00:18:11.310
和我們可以使用的方式

00:18:11.310 --> 00:18:14.760
那些比
只是說取消訂閱。

00:18:14.760 --> 00:18:18.700
所以有些很酷
你能做到的方法

00:18:18.700 --> 00:18:20.680
您可以輕鬆地管理
這些生命時期。

00:18:20.680 --> 00:18:25.359
所以記住你以前在哪裡
以確保取消訂閱,

00:18:25.359 --> 00:18:28.600
比如在Xamarin表格中,

00:18:28.600 --> 00:18:32.590
如果要更改元素
或者,如果有什麼新來

00:18:32.590 --> 00:18:34.210
在你想訂閱

00:18:34.210 --> 00:18:36.325
而你不在乎
舊事了

00:18:36.325 --> 00:18:40.000
你必須做這個事情,在那裡
你取消訂閱舊的,

00:18:40.000 --> 00:18:41.290
訂閱新的,

00:18:41.290 --> 00:18:44.920
然後也你的處置點有

00:18:44.920 --> 00:18:48.955
以確保您取消訂閱
從這些事件,以及。

00:18:48.955 --> 00:18:50.650
所以,這是整潔的,

00:18:50.650 --> 00:18:57.070
是,你的整個事件
觀測管理系統

00:18:57.070 --> 00:19:00.055
可以鉸接
通過一次性。

00:19:00.055 --> 00:19:02.740
我們採取行動,很多
這些東西在這裡

00:19:02.740 --> 00:19:05.215
我希望他們只是拉
到the.Net框架,

00:19:05.215 --> 00:19:08.290
但現在,在

00:19:08.290 --> 00:19:11.440
反應X你有這些東西
像複合可支配。

00:19:11.440 --> 00:19:13.450
所以這個想法有
您可以聚合

00:19:13.450 --> 00:19:17.035
你所有的一次性用品
單個資料結構,

00:19:17.035 --> 00:19:20.260
然後是現在的資料結構,

00:19:20.260 --> 00:19:22.225
你可以只處理一次

00:19:22.225 --> 00:19:26.125
一旦一生
包含類消失了,

00:19:26.125 --> 00:19:28.540
現在你所有的活動
管理是照顧。

00:19:28.540 --> 00:19:33.310
因此,您可以附加您的
屬性更改了訂閱,

00:19:33.310 --> 00:19:37.570
您的 Text 更改訂閱,
然後你就把它處理掉

00:19:37.570 --> 00:19:38.650
所以這是整潔的,因為你得到

00:19:38.650 --> 00:19:44.200
這些物件的概念,
你可以申請你的活動,

00:19:44.200 --> 00:19:48.740
所以這很好,我喜歡。

00:19:51.900 --> 00:19:55.030
例如,就像我
談論之前,

00:19:55.030 --> 00:19:57.430
你有一個實例

00:19:57.430 --> 00:19:59.725
你有一個老元素
你訂閱了

00:19:59.725 --> 00:20:01.000
我的意思是一個新的元素來了

00:20:01.000 --> 00:20:04.690
所以你不關心
舊的了。

00:20:04.690 --> 00:20:06.310
因此,它有像這些很酷的概念

00:20:06.310 --> 00:20:08.110
這裡像一個串列處置,

00:20:08.110 --> 00:20:09.910
你什麼
分配給該意志

00:20:09.910 --> 00:20:12.250
自動處置
之前的東西。

00:20:12.250 --> 00:20:14.980
所以在這些想法中,

00:20:14.980 --> 00:20:16.900
你不必

00:20:16.900 --> 00:20:19.690
取消訂閱什麼來
那裡,這是真的很整潔。

00:20:19.690 --> 00:20:23.530
但是你知道這是
你關心的新熱,

00:20:23.530 --> 00:20:25.390
然後一旦進來

00:20:25.390 --> 00:20:28.735
你只是擺脫
不管以前有什麼

00:20:28.735 --> 00:20:30.370
這樣,就可以讓你設置

00:20:30.370 --> 00:20:36.470
這些很酷的表達
你想做什麼。

00:20:37.320 --> 00:20:41.770
因為很多東西
反應性,這真的很好,

00:20:41.770 --> 00:20:47.560
擁有你所有的意圖
在一個位置。

00:20:47.560 --> 00:20:51.050
事件管理是
非常基於回檔,

00:20:52.080 --> 00:20:56.320
你沒有得到壞的風格
就像一個完全的回檔地獄,

00:20:56.320 --> 00:20:58.645
但它仍然是善良的
同樣的事情。

00:20:58.645 --> 00:21:01.330
這是回檔管理
然後交互

00:21:01.330 --> 00:21:03.760
所有這些不同的回檔
場景時,你有

00:21:03.760 --> 00:21:06.665
同樣的事情,你如何
管理它的壽命。

00:21:06.665 --> 00:21:13.470
但這裡有人做過嗎
夏馬林形成東西？

00:21:13.470 --> 00:21:17.050
我只是映射
邏輯建模在這裡。

00:21:17.050 --> 00:21:20.455
所以你現在有這個想法,在哪裡

00:21:20.455 --> 00:21:25.690
的方式,你可以

00:21:25.690 --> 00:21:27.250
管理

00:21:27.250 --> 00:21:30.635
事情恰到好處
在中間部分,

00:21:30.635 --> 00:21:33.840
這就是你要做的一切。

00:21:33.840 --> 00:21:36.315
一旦在那裡設置,

00:21:36.315 --> 00:21:40.635
現在任何時候你進來,
你有一個元素的變化,

00:21:40.635 --> 00:21:42.650
你只關心
關於新元素,

00:21:42.650 --> 00:21:47.230
分配新的一次性原因
前一個處置,

00:21:47.230 --> 00:21:49.990
所以現在你的所有事件
完全未連接,

00:21:49.990 --> 00:21:52.645
然後現在你開始
佈線你的新的。

00:21:52.645 --> 00:21:53.860
然後在你處置,

00:21:53.860 --> 00:21:56.260
你只有一個單一的
串列處置,這是

00:21:56.260 --> 00:22:01.750
類級別託管資源
你正在處理。

00:22:01.750 --> 00:22:06.880
所以現在沒有

00:22:06.880 --> 00:22:10.480
管理的複雜性
就你的提前處理。

00:22:10.480 --> 00:22:13.300
所以這實際上是
第一件事,讓我進入

00:22:13.300 --> 00:22:17.630
反應程式設計是
一次性管理,

00:22:18.900 --> 00:22:22.150
我想就像一年前一樣
我甚至用過別的

00:22:22.150 --> 00:22:25.540
就因為我有一盞銀光
應用程式有

00:22:25.540 --> 00:22:30.775
一些訂閱問題和
然後我偶然發生了這種事

00:22:30.775 --> 00:22:32.815
所以這個東西很酷

00:22:32.815 --> 00:22:34.870
一次性用品讓我超級快樂。

00:22:34.870 --> 00:22:37.390
因此,這些仍然映射一些

00:22:37.390 --> 00:22:40.120
這些想法,這是
真的很整潔,所以就像這裡,

00:22:40.120 --> 00:22:42.700
記得之前,當你
只想訂閱

00:22:42.700 --> 00:22:45.445
一個事件,你只有
想看一次嗎？

00:22:45.445 --> 00:22:48.640
使用"反應",您可以執行

00:22:48.640 --> 00:22:52.045
整個概念在這裡
用這個運算式。

00:22:52.045 --> 00:22:54.160
所以這一切都說明了,

00:22:54.160 --> 00:22:58.839
"我只想從一個值
此屬性已更改,

00:22:58.839 --> 00:23:02.680
然後,在那個點,我
想要你擺脫它。

00:23:02.680 --> 00:23:05.335
我是說那太棒了

00:23:05.335 --> 00:23:07.555
取一個,然後切換,

00:23:07.555 --> 00:23:10.180
這是一個有點棘手
理解,但這些都是

00:23:10.180 --> 00:23:13.270
只是足夠的理由
永遠使用它,

00:23:13.270 --> 00:23:15.340
很好,我喜歡。

00:23:15.340 --> 00:23:22.210
所以,這是細分
操作如何工作。

00:23:22.210 --> 00:23:31.670
所以我有幾個演示
在代碼中實現這一點多一點,

00:23:33.360 --> 00:23:39.970
但我想給一些概念
準備給你,以及,

00:23:39.970 --> 00:23:45.700
到一些反應性類型
我們使用的結構,

00:23:45.700 --> 00:23:47.980
只是,所以它更有意義一點。

00:23:47.980 --> 00:23:50.500
所以,你描述的東西的方式之一

00:23:50.500 --> 00:23:53.185
與反應是
使用大理石圖,

00:23:53.185 --> 00:23:55.075
所以有這些想法看到

00:23:55.075 --> 00:24:01.405
您的輸入和輸出是什麼。

00:24:01.405 --> 00:24:03.760
所以這裡前兩名

00:24:03.760 --> 00:24:10.285
這是白話
最被動的資訊,

00:24:10.285 --> 00:24:14.800
所以任何時候你看到
描述的反應運算子:

00:24:14.800 --> 00:24:16.330
他們總是被描述
以此格式。

00:24:16.330 --> 00:24:19.810
所以這裡的想法是
前兩件事是資料流程,

00:24:19.810 --> 00:24:23.480
然後底部一個是
訂閱者看到的內容。

00:24:24.420 --> 00:24:27.519
合併將是兩個訂閱者,

00:24:27.519 --> 00:24:29.980
所以,如果你訂閱
說出 TextChanged 事件

00:24:29.980 --> 00:24:36.175
在使用者名框和
例如,密碼框,

00:24:36.175 --> 00:24:38.620
任何時候任一
這些變化,這是

00:24:38.620 --> 00:24:40.690
您的輸出會是什麼樣子。

00:24:40.690 --> 00:24:43.360
因此,這些都是一些
我在演示中使用的運算子,

00:24:43.360 --> 00:24:44.620
所以我只想

00:24:44.620 --> 00:24:50.350
以確保他們
理解之前,我繼續前進。

00:24:50.350 --> 00:24:53.350
所以篩檢程式,這是
基本上就像一個地方,

00:24:53.350 --> 00:24:57.460
所以連結到iEbleble,

00:24:57.460 --> 00:25:00.280
就像個地方一樣

00:25:00.280 --> 00:25:02.260
如此有效地任何事件來

00:25:02.260 --> 00:25:05.810
通過,簡單到足以理解。

00:25:05.850 --> 00:25:09.100
去跳,所以這是
另一個非常酷的功能,

00:25:09.100 --> 00:25:11.395
因此,這是限制您的輸入。

00:25:11.395 --> 00:25:13.570
所以在這個例子中,他們是什麼

00:25:13.570 --> 00:25:16.210
這裡演示的是
他們只想

00:25:16.210 --> 00:25:17.710
最新的值來

00:25:17.710 --> 00:25:21.025
出後,一定的
設置時間量。

00:25:21.025 --> 00:25:25.840
所以你可以看到有一個滯後
一到五之間,因為兩個,

00:25:25.840 --> 00:25:27.745
三,四是

00:25:27.745 --> 00:25:30.280
發生如此接近
那五個現在出來了。

00:25:30.280 --> 00:25:33.910
所以這是典型的
反應性的東西的例子,

00:25:33.910 --> 00:25:36.850
所以情況下,使用者

00:25:36.850 --> 00:25:39.400
做喜歡搜索

00:25:39.400 --> 00:25:42.305
谷歌,當他們打字
在他們的自動完成,

00:25:42.305 --> 00:25:45.220
但你不想踢
每次關閉網路請求,

00:25:45.220 --> 00:25:48.640
所以這是有效的什麼
這是演示,

00:25:48.640 --> 00:25:50.305
我們有一個例子。

00:25:50.305 --> 00:25:56.640
然後採取直到是
我使用的最後一個運算子,

00:25:56.640 --> 00:25:58.110
所以TakeTake直到真的很整潔,

00:25:58.110 --> 00:26:01.170
因為那是例如
看起來像一個 Web 請求。

00:26:01.170 --> 00:26:04.605
因此,讓我們說一個網路請求
正在啟動,

00:26:04.605 --> 00:26:07.210
然後使用者
重新開始鍵入,

00:26:07.210 --> 00:26:09.880
或者他們說取消,

00:26:09.880 --> 00:26:11.560
就像他們不想
它再次發生,

00:26:11.560 --> 00:26:16.360
所以所有這些是另一個
事件點,你可以頒佈,

00:26:16.360 --> 00:26:19.465
在那個點上,它削減
離開你的流了。

00:26:19.465 --> 00:26:22.375
所以,這就像一個真正的
簡單的方法說切斷,

00:26:22.375 --> 00:26:25.940
如果您不想要 Web 請求
或類似的東西完成。

00:26:25.940 --> 00:26:32.400
這就是崩潰
可觀察的東西,

00:26:32.400 --> 00:26:35.470
讓我換個開關

00:26:36.080 --> 00:26:39.380
保持一秒鐘。

00:26:39.380 --> 00:26:52.660
酷,讓我們看看。

00:26:53.540 --> 00:26:55.875
太小了嗎？

00:26:55.875 --> 00:26:57.610
* 是的。

00:26:58.710 --> 00:27:01.330
* 這是東西,你
做當你意識到

00:27:01.330 --> 00:27:04.000
你從來沒有做過
這些在演示之前,

00:27:04.000 --> 00:27:07.525
其實我從未增加過
其字體大小在Obs Mac之前。

00:27:07.525 --> 00:27:16.300
我看看。我試著
做我的Windows的東西在這裡,

00:27:16.300 --> 00:27:20.540
我們走吧,我猜就是這個

00:27:22.580 --> 00:27:26.610
好吧,我試了
我在墊子上的手勢。

00:27:26.610 --> 00:27:27.630
我刷卡了

00:27:27.630 --> 00:27:28.650
我做了兩根手指

00:27:28.650 --> 00:27:32.670
我這麼做了我不知道。

00:27:32.670 --> 00:27:35.280
我猜我沒有發生。

00:27:35.280 --> 00:27:45.015
因此,我們去。好的,是的。

00:27:45.015 --> 00:27:46.740
所以當你開始視窗
你剛才打的地方

00:27:46.740 --> 00:27:48.615
控制和拆分它。

00:27:48.615 --> 00:27:51.910
好吧,讓每個人都
可以看到這一點。好吧？

00:27:52.070 --> 00:27:55.410
所以讓我運行演示真實

00:27:55.410 --> 00:27:59.895
快速只是所以我們有上下文
我們在這裡做什麼。

00:27:59.895 --> 00:28:02.640
所以,這是一種
一個基本應用程式。

00:28:02.640 --> 00:28:08.355
這只是一個登錄登出的想法。

00:28:08.355 --> 00:28:14.265
是的,所以下面我有一套
正在發生的事件,

00:28:14.265 --> 00:28:21.690
所以這是有效的
可觀測資料流程。

00:28:21.690 --> 00:28:23.970
所以所有的事件
發生與可觀察。

00:28:23.970 --> 00:28:25.365
因此,我們在這裡登錄。

00:28:25.365 --> 00:28:27.240
這就是使用者和密碼

00:28:27.240 --> 00:28:28.665
我應該把
預留位置日誌。

00:28:28.665 --> 00:28:34.095
但在這裡,你的想法
可以看到我是否打了一封信。

00:28:34.095 --> 00:28:36.509
那裡。所以打一封信

00:28:36.509 --> 00:28:39.090
在那個點上,它的
驗證輸入。

00:28:39.090 --> 00:28:41.175
現在你可以看到
有這種延遲。

00:28:41.175 --> 00:28:43.935
對？所以如果我打
"O"有延遲。

00:28:43.935 --> 00:28:46.170
所以背後的理念
也就是說,你

00:28:46.170 --> 00:28:49.455
不, 這是脫彈跳
你說的

00:28:49.455 --> 00:28:54.945
因此,如果我鍵入"使用者名"
和"密碼"。

00:28:54.945 --> 00:28:59.310
那裡。你可以看到,一次
驗證發生。

00:28:59.310 --> 00:29:01.710
所以,這只是我們有點休息
下來這些結構,一旦我

00:29:01.710 --> 00:29:04.275
在那裡,但這是
背後的想法。

00:29:04.275 --> 00:29:08.910
所以。是的。太令人興奮了

00:29:08.910 --> 00:29:11.955
現在,我們有一個類比登錄。

00:29:11.955 --> 00:29:14.250
所以在這裡的想法,我點擊"登錄"。

00:29:14.250 --> 00:29:18.840
它啟動一個 Web 請求,然後
此時,您可以登出。

00:29:18.840 --> 00:29:21.870
所以,有一種

00:29:21.870 --> 00:29:26.415
額外讓我們看看多少次
它需要在此觸發器之前。

00:29:26.415 --> 00:29:30.090
所以我有個隨機器
在那裡隨機

00:29:30.090 --> 00:29:35.415
建置錯誤。就是這裡。

00:29:35.415 --> 00:29:38.400
酷。所以你可以看到這裡什麼

00:29:38.400 --> 00:29:41.775
發生是,我
點擊"登錄"。

00:29:41.775 --> 00:29:44.535
它生成了異常。

00:29:44.535 --> 00:29:47.895
因此,就像 Web 請求異常一樣。

00:29:47.895 --> 00:29:51.630
然後它說好,讓我們只是
再次嘗試 Web 請求。

00:29:51.630 --> 00:29:59.640
然後,在那個點
然後登錄我,對嗎？

00:29:59.640 --> 00:30:02.655
然後另一個方面
這是我。

00:30:02.655 --> 00:30:05.070
就像假設使用者
想取消它。

00:30:05.070 --> 00:30:09.100
因此,如果他們點擊"登錄"
他們可以按一下"取消"。

00:30:09.350 --> 00:30:13.470
在那裡你可以看到,現在它不是
處理資料的時間較長。

00:30:13.470 --> 00:30:16.035
對？所以,因為

00:30:16.035 --> 00:30:18.885
有一種手術
取消。

00:30:18.885 --> 00:30:23.805
因此,這是演示。

00:30:23.805 --> 00:30:25.815
是的,這就是背後的理念。

00:30:25.815 --> 00:30:27.900
這是代碼。

00:30:27.900 --> 00:30:32.160
是的,所以這個想法

00:30:32.160 --> 00:30:34.965
在這背後種
分解結構。

00:30:34.965 --> 00:30:37.935
自從我們都見過很多
這些東西是,

00:30:37.935 --> 00:30:41.340
這是可組合性
可觀察的方面。

00:30:41.340 --> 00:30:43.890
可組合性方面
是你有

00:30:43.890 --> 00:30:46.920
您的事件的這種表示形式

00:30:46.920 --> 00:30:50.730
這些單一資料流程
然後,你可以開始

00:30:50.730 --> 00:30:55.845
混合表達
應用程式的行為。

00:30:55.845 --> 00:31:01.050
所以,如果我們有應用程式是什麼
這裡的所有事件流。

00:31:01.050 --> 00:31:03.360
事件流是
我們有條目

00:31:03.360 --> 00:31:07.065
頂部,我們有條目
在第二個欄位。

00:31:07.065 --> 00:31:10.320
作為使用者類型,我們有
按一下"登錄"按鈕。

00:31:10.320 --> 00:31:12.975
我們有取消按鈕點擊
我們有像網路請求。

00:31:12.975 --> 00:31:17.205
因此,我們有效地
五個不同的事件。

00:31:17.205 --> 00:31:20.550
我們需要描述的流。

00:31:20.550 --> 00:31:28.545
所以我們可以打破這些
到他們的反應部分。

00:31:28.545 --> 00:31:32.145
所以,這些都是相當不令人興奮。

00:31:32.145 --> 00:31:37.050
和你一樣
看到之前,這是基本上

00:31:37.050 --> 00:31:39.180
只是說嘿,我想創造這個

00:31:39.180 --> 00:31:42.630
可觀察的,這是聽
到按一下的事件。

00:31:42.630 --> 00:31:46.095
所以這是核心方面
這是令人興奮的。

00:31:46.095 --> 00:31:51.825
因此,我們創建一個可觀察
每個不同的元素。

00:31:51.825 --> 00:31:54.030
我們有我們的登錄名。

00:31:54.030 --> 00:31:55.470
因此,當他們點擊。

00:31:55.470 --> 00:31:56.805
我們有登出。

00:31:56.805 --> 00:31:58.440
那是他們登出的時候。

00:31:58.440 --> 00:32:01.785
我們有取消。那是
當他們點擊"取消"

00:32:01.785 --> 00:32:06.750
我們有文本更改
在這裡,這是當他們

00:32:06.750 --> 00:32:09.000
鍵入使用者名,我們有

00:32:09.000 --> 00:32:12.090
密碼在這裡時,他們
鍵入密碼。

00:32:12.090 --> 00:32:15.300
然後,我們
一個假的網路請求調用。

00:32:15.300 --> 00:32:17.670
因此,這只是展示。

00:32:17.670 --> 00:32:20.565
它本質上只是
等待兩秒鐘。

00:32:20.565 --> 00:32:22.440
然後,一旦它完成它生成

00:32:22.440 --> 00:32:26.265
如果某個隨機錯誤
數位等於 2。

00:32:26.265 --> 00:32:35.010
是的。這就是我們的應用程式。

00:32:35.010 --> 00:32:38.250
這是可觀察的
表示

00:32:38.250 --> 00:32:41.985
可能發生的所有事件
在申請中,對嗎？

00:32:41.985 --> 00:32:43.860
所以,現在這是

00:32:43.860 --> 00:32:47.680
可組合性方面來了
發揮,這真的很酷。

00:32:48.500 --> 00:32:51.150
現在,所有這些
不同的可觀測

00:32:51.150 --> 00:32:53.220
自己的生活。

00:32:53.220 --> 00:33:00.060
所以整個
你看到的邏輯

00:33:00.060 --> 00:33:06.990
有體現與一個相當
簡單的代碼量,對不對？

00:33:06.990 --> 00:33:12.780
因此,這裡是我們的驗證代碼。

00:33:12.780 --> 00:33:14.940
所以現在我們要做的就是
我們正在建立

00:33:14.940 --> 00:33:18.810
上的其他可觀測項
這些其他可觀察的。

00:33:18.810 --> 00:33:21.990
對？所以這就是
可組合性方面。

00:33:21.990 --> 00:33:23.640
所以第一個是,我們

00:33:23.640 --> 00:33:26.520
說好,我們要一個
經過身份驗證的可觀察性。

00:33:26.520 --> 00:33:29.580
經過身份驗證的可觀測
是使用者按一下

00:33:29.580 --> 00:33:33.060
"登錄"並按一下
關閉"Web 請求"。

00:33:33.060 --> 00:33:39.090
所以,現在我們已經組成了這兩個
可觀察事件的想法。

00:33:39.090 --> 00:33:42.870
現在,我們合併了此資料
流與登出。

00:33:42.870 --> 00:33:47.250
因此,如果使用者按一下"登出"
然後說"嘿,

00:33:47.250 --> 00:33:48.735
我要你登出。

00:33:48.735 --> 00:33:54.480
因此,我們有整個
身份驗證狀態

00:33:54.480 --> 00:34:00.525
代表的應用程式
一個新的可觀察的認證。

00:34:00.525 --> 00:34:02.295
已驗證的可觀察性。

00:34:02.295 --> 00:34:05.295
所以,這是唯一可觀察到的
在這一點上,我們關心。

00:34:05.295 --> 00:34:07.530
所以,這就是我們現在可以使用

00:34:07.530 --> 00:34:09.540
可觀察到任何地方,我們

00:34:09.540 --> 00:34:14.940
想問什麼是
使用者已過身份驗證。

00:34:14.940 --> 00:34:18.190
你知道哪個是需要的

00:34:19.910 --> 00:34:22.620
然後在這裡,我們有我們的驗證。

00:34:22.620 --> 00:34:24.720
我們的驗證是

00:34:24.720 --> 00:34:29.410
我們的使用者名和密碼
那裡是不錯的。

00:34:29.570 --> 00:34:33.645
因此,這基本上進來。

00:34:33.645 --> 00:34:35.894
上面寫著"嘿

00:34:35.894 --> 00:34:38.909
這些是資料點
代表有效性。

00:34:38.909 --> 00:34:43.080
它將這些事件轉換為

00:34:43.080 --> 00:34:47.910
真實或虛假的值,我們
現在可以使用說,"好吧。

00:34:47.910 --> 00:34:53.860
事件的狀態是什麼
已經進來了？"

00:34:55.190 --> 00:34:58.515
那麼現在讓我們

00:34:58.515 --> 00:35:01.455
放在一起-現在我們可以把
所有這些東西在一起。

00:35:01.455 --> 00:35:03.120
這是那種
像功能

00:35:03.120 --> 00:35:05.295
反應程式設計方面
來發揮。

00:35:05.295 --> 00:35:08.880
我們現在可以把所有這些不同的
可觀察的一起成

00:35:08.880 --> 00:35:10.485
一個不錯的小地方

00:35:10.485 --> 00:35:15.255
在這裡,描述一切
那會發生

00:35:15.255 --> 00:35:17.760
所以這是
它真的很整潔。

00:35:17.760 --> 00:35:22.995
因為有了這個
應用程式,你可以得到

00:35:22.995 --> 00:35:27.120
所有透視範圍

00:35:27.120 --> 00:35:31.710
邏輯只是通過正確
在這裡的代碼點。

00:35:31.710 --> 00:35:36.060
不必
跳來跳去或任何東西。

00:35:36.060 --> 00:35:40.170
這是一個不可變的位置,基於

00:35:40.170 --> 00:35:46.485
不可修改的資料
這些資料點的工作原理。

00:35:46.485 --> 00:35:50.190
所以這很好,因為
這是一個不錯的簡單方法。

00:35:50.190 --> 00:35:53.490
所以就像來的資料
在此結果值中,此處

00:35:53.490 --> 00:35:57.450
是不可變的結構。

00:35:57.450 --> 00:36:00.435
然後,基於此資料,您
知道經過身份驗證的可觀察性。

00:36:00.435 --> 00:36:02.760
那麼,這在做什麼
這裡是說什麼

00:36:02.760 --> 00:36:06.315
您的身份驗證狀態是
您是否經過身份驗證。

00:36:06.315 --> 00:36:10.845
有效是說是否
他們輸入的憑據有效。

00:36:10.845 --> 00:36:12.360
然後基於這一點,

00:36:12.360 --> 00:36:17.320
設置可見度
您的應用程式。

00:36:20.170 --> 00:36:22.890
是的,所以你可以設置
像能見度

00:36:22.890 --> 00:36:26.200
您的應用程式。所以,它是整潔的。

00:36:28.340 --> 00:36:31.905
讓我們看看。

00:36:31.905 --> 00:36:34.350
我還有一個演示真正的快速,

00:36:34.350 --> 00:36:36.820
只是一個小的。

00:36:39.350 --> 00:36:43.725
哎呀,有點太大了
那裡。我們開始吧。

00:36:43.725 --> 00:36:45.345
大家都看到了嗎？

00:36:45.345 --> 00:36:50.400
是的。好吧。我有這些
像 GitHub 存儲庫一樣。

00:36:50.400 --> 00:36:53.520
這是使用一點點
反應性 UI 的東西,

00:36:53.520 --> 00:36:55.695
但讓我展示一下

00:36:55.695 --> 00:37:00.730
有幾個不同的示例
你可以看看。

00:37:02.360 --> 00:37:10.240
希望它運行。是嗎
已經運行？在那裡,它去。

00:37:10.940 --> 00:37:14.980
所以很多這些是
簡單的事情,你看到。

00:37:15.050 --> 00:37:17.775
讓我們來看看
位置演示,因為我們

00:37:17.775 --> 00:37:19.905
運行低時間在這裡。

00:37:19.905 --> 00:37:21.900
因此,位置演示的想法

00:37:21.900 --> 00:37:24.810
是你跟蹤的
滑鼠指標。

00:37:24.810 --> 00:37:30.780
這有另一個流行的示例
反應概念。

00:37:30.780 --> 00:37:32.055
所以你往下推

00:37:32.055 --> 00:37:33.660
它檢測到您按下。

00:37:33.660 --> 00:37:34.740
如果你移動你的滑鼠,

00:37:34.740 --> 00:37:36.000
現在它檢測到你移動了

00:37:36.000 --> 00:37:37.380
然後你放手,它給

00:37:37.380 --> 00:37:40.335
您所有資料的聚合。

00:37:40.335 --> 00:37:49.380
有點壞了

00:37:49.380 --> 00:37:51.720
因為我需要
描述,

00:37:51.720 --> 00:37:56.080
但它真的很整潔,因為
你真正要做的一切

00:37:56.120 --> 00:37:58.905
您有指標按下事件。

00:37:58.905 --> 00:38:01.200
所以你有指標
新聞說,

00:38:01.200 --> 00:38:03.840
"嘿,我把滑鼠按下了。

00:38:03.840 --> 00:38:06.840
現在,一旦這有
發生了,你說,"好吧,

00:38:06.840 --> 00:38:10.395
我想訂閱
指標被移動左右。

00:38:10.395 --> 00:38:14.170
所以,這是現在的指標
被移動。

00:38:14.240 --> 00:38:16.800
當它正在移動時,

00:38:16.800 --> 00:38:20.085
你拉所有這些資料
一起在這裡,

00:38:20.085 --> 00:38:23.145
然後是兩個清單運算子,在這裡,

00:38:23.145 --> 00:38:24.960
現在能夠
聚合所有資料

00:38:24.960 --> 00:38:27.405
一起到單個資料集中。

00:38:27.405 --> 00:38:29.760
然後在這裡,直到那

00:38:29.760 --> 00:38:32.220
一個操作,
我們在這裡展示。

00:38:32.220 --> 00:38:34.170
上面寫著"嘿,好吧,
我只想讓你

00:38:34.170 --> 00:38:36.270
採取這些資料,並告訴
指標釋放。

00:38:36.270 --> 00:38:38.309
所以,你得到這個真的
很酷的相互作用

00:38:38.309 --> 00:38:40.020
所有這些事件說,

00:38:40.020 --> 00:38:41.940
因為你真正想要的
說是我想移動

00:38:41.940 --> 00:38:44.130
滑鼠周圍和當
他們放開了老鼠

00:38:44.130 --> 00:38:45.810
我想要所有的資料在那裡。

00:38:45.810 --> 00:38:47.160
所以,你可以得到這一切

00:38:47.160 --> 00:38:50.505
代表在這個漂亮的
小訂閱在這裡。

00:38:50.505 --> 00:38:55.120
所以這是其中一個
這些主要的例子。

00:38:57.130 --> 00:39:03.360
是的,所以這是一個快速入門
到反應性的概念。

00:39:04.690 --> 00:39:08.940
有很多
良好的框架在那裡。

00:39:11.210 --> 00:39:16.740
哎呀,沒用。我們開始吧。

00:39:16.740 --> 00:39:23.280
是的。這就是背後的理念
大多數可觀測。

00:39:23.280 --> 00:39:25.530
邁克爾要談談
更多有關使用

00:39:25.530 --> 00:39:28.545
這些框架與 MVVM。

00:39:28.545 --> 00:39:32.880
有很多非常強大
動態資料等工具。

00:39:32.880 --> 00:39:35.100
選擇動態資料,它是

00:39:35.100 --> 00:39:37.590
一個非常酷的平臺

00:39:37.590 --> 00:39:41.985
在你的清單中的超級大國
可觀察。

00:39:41.985 --> 00:39:43.890
所以這個想法是,你可以

00:39:43.890 --> 00:39:46.995
基本上使
一切和可觀察。

00:39:46.995 --> 00:39:49.660
你可以簽署
我不知道。

00:39:51.470 --> 00:39:53.610
所以我想真的很快

00:39:53.610 --> 00:39:55.960
有人有疑問嗎？

00:39:57.410 --> 00:40:00.720
是的,山姆是的。

00:40:00.720 --> 00:40:04.095
我們去那裡吧我們會
做問題約35分鐘。

00:40:04.095 --> 00:40:05.520
• 所以談談

00:40:05.520 --> 00:40:10.380
披露
[聽不見]和所有的東西。

00:40:10.380 --> 00:40:14.220
談論為什麼可觀察
更好[聽不見]。

00:40:14.220 --> 00:40:20.460
* 是的,所以我

00:40:20.460 --> 00:40:24.045
我想我會說,因為
管理-所以問題是,

00:40:24.045 --> 00:40:25.680
記憶體洩漏

00:40:25.680 --> 00:40:28.290
為什麼事實,它返回

00:40:28.290 --> 00:40:31.245
一次性更好的第一
說記憶體管理？

00:40:31.245 --> 00:40:33.090
那裡的想法是,是的,

00:40:33.090 --> 00:40:37.230
事實是
這是一生

00:40:37.230 --> 00:40:43.665
可觀測是一個方面
訂閱。

00:40:43.665 --> 00:40:46.920
所以當你訂閱時
到它,你回來,

00:40:46.920 --> 00:40:49.395
因為任何時候你得到
一次性的

00:40:49.395 --> 00:40:51.270
你知道你有
處置它。

00:40:51.270 --> 00:40:54.630
就像這就是我們使用的範例一樣。

00:40:54.630 --> 00:40:57.060
這就是它的想法。

00:40:57.060 --> 00:41:01.365
是通風
尤其對於新程式師來說,

00:41:01.365 --> 00:41:03.660
他們總是要
把這當成錯誤

00:41:03.660 --> 00:41:07.700
哪裡像的東西的

00:41:07.700 --> 00:41:08.810
要活得比別的東西還多

00:41:08.810 --> 00:41:10.250
因為你必須明白

00:41:10.250 --> 00:41:15.360
但一次性是
一個非常基本的概念。

00:41:15.360 --> 00:41:19.155
因此,有作為一部分
訂閱

00:41:19.155 --> 00:41:22.860
讓你的記憶體管理
方案更容易。

00:41:22.860 --> 00:41:25.440
是的。

00:41:25.440 --> 00:41:26.940
還有其他問題嗎？

00:41:26.940 --> 00:41:28.727
是的。

00:41:28.727 --> 00:41:35.250
[ 聽不到]。

00:41:35.250 --> 00:41:39.060
* 是的。所以問題是

00:41:39.060 --> 00:41:41.985
能否使用反應程式設計

00:41:41.985 --> 00:41:45.060
與像任務或
非同步程式設計？

00:41:45.060 --> 00:41:50.865
是的。因此,任務是有效的
一點通知。

00:41:50.865 --> 00:41:53.355
所以當你有任務的時候

00:41:53.355 --> 00:41:57.210
有三個資料點
任務與

00:41:57.210 --> 00:42:02.175
我們的反覆運算器,當我們指示。

00:42:02.175 --> 00:42:05.040
所以當你寫任務的時候

00:42:05.040 --> 00:42:06.615
我不知道它在哪裡
未來。好吧。

00:42:06.615 --> 00:42:08.190
所以當你有任務的時候

00:42:08.190 --> 00:42:14.145
創建任務,以便
你一開始就有它,

00:42:14.145 --> 00:42:19.724
然後你開始任務
所以現在它運行,

00:42:19.724 --> 00:42:23.355
然後任務產生一個值,

00:42:23.355 --> 00:42:26.445
這是你的點結果
我們都沒有在打字

00:42:26.445 --> 00:42:29.970
然後完成
完成。

00:42:29.970 --> 00:42:31.440
所以在那個時候

00:42:31.440 --> 00:42:35.190
您有一個可觀測的資料點。

00:42:35.190 --> 00:42:40.680
所以一次性創造的東西

00:42:40.680 --> 00:42:42.900
工作完全對任務,所以

00:42:42.900 --> 00:42:45.180
您可以創建
可針對任務進行觀察。

00:42:45.180 --> 00:42:49.125
那麼,將會發生什麼是當
你訂閱了那個可觀察的,

00:42:49.125 --> 00:42:54.494
是它會有效地開始任務
然後一旦發生這種情況

00:42:54.494 --> 00:42:56.190
踢回一個結果。

00:42:56.190 --> 00:42:59.655
因此,產生一個值
然後它完成。

00:42:59.655 --> 00:43:01.410
那又是另一回事
這真的超級

00:43:01.410 --> 00:43:03.600
有説明,因為如果任務失敗,

00:43:03.600 --> 00:43:05.040
你得到你的東西

00:43:05.040 --> 00:43:07.485
可觀察的,你在哪裡
可以捕獲異常。

00:43:07.485 --> 00:43:13.500
例如,方案
例如,像非同步空。

00:43:13.500 --> 00:43:16.575
非同步無效是非問題
可觀察。

00:43:16.575 --> 00:43:18.495
你不用擔心

00:43:18.495 --> 00:43:21.970
非同步無效如果你
做可觀察的。

00:43:22.040 --> 00:43:26.520
例如,你知道你如何
可能想要啟動非同步任務

00:43:26.520 --> 00:43:28.050
從建構函式或類似的東西

00:43:28.050 --> 00:43:30.060
或這些問題從
那些有可觀察性,

00:43:30.060 --> 00:43:31.200
這甚至不是一個場景,

00:43:31.200 --> 00:43:34.320
因為你只是把任務包裝在

00:43:34.320 --> 00:43:36.180
可觀察,然後你有

00:43:36.180 --> 00:43:39.225
異常行為作為一部分
可觀察的任務。

00:43:39.225 --> 00:43:40.710
所以,是的,他們工作。

00:43:40.710 --> 00:43:42.060
它們非常適合執行任務。

00:43:42.060 --> 00:43:43.770
所以,在那裡,我忘了誰說話。

00:43:43.770 --> 00:43:46.260
傑佛瑞或類似的東西
做一個談話;

00:43:46.260 --> 00:43:48.015
談論任務是如何

00:43:48.015 --> 00:43:50.010
超級壞,你應該
只使用可觀察的。

00:43:50.010 --> 00:43:51.360
但是,是的,一旦你開始使用

00:43:51.360 --> 00:43:53.685
可觀測性特別強
在 UI 代碼中,

00:43:53.685 --> 00:43:55.260
你會有效地只是把

00:43:55.260 --> 00:43:57.420
在所有人面前的立面
你的任務,因為

00:43:57.420 --> 00:44:02.080
它變得如此簡單
通過可觀察的進行管理。

00:44:02.450 --> 00:44:04.905
還有其他問題嗎？

00:44:04.905 --> 00:44:07.840
我拿到了

00:44:09.380 --> 00:44:12.870
我能再拿一個嗎？
問題？不？好吧,不

00:44:12.870 --> 00:44:15.075
我會回答你的
問題後。

00:44:15.075 --> 00:44:17.340
酷。所以,是的,我是謝恩。

00:44:17.340 --> 00:44:20.500
那是我的觀察點。