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
那是我的观察点。