WEBVTT

00:00:00.000 --> 00:00:03.190
>> すべての権利。こんにちは。
皆元気か?

00:00:03.380 --> 00:00:08.280
第四の道を通る
私たちのザムサミットはここです。

00:00:08.280 --> 00:00:12.870
そう、私はシェーンです
ヌーヴィル。スペルは正しいのか?

00:00:12.870 --> 00:00:17.715
うん。シェーン・ヌーヴィル私は
ザマリンフォームズチームと一緒に。

00:00:17.715 --> 00:00:20.280
ザマリンフォームを使用する前に、

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とReactJSについて?

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
1時間ぐらい?違います。大丈夫です。

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
だから私は最初のことを覚えている
私はReactJSのことを聞いた時間。

00:01:39.980 --> 00:01:42.955
私はしばらくの間RxJSをやっていました。

00:01:42.955 --> 00:01:45.380
約5分でした
会話に、

00:01:45.380 --> 00:01:48.695
私たちは持っていないことに気づいた
同じ会話。

00:01:48.695 --> 00:01:51.890
だから、本当にありません

00:01:51.890 --> 00:01:55.920
そこに他の関係
最初の 5 文字。

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
したがって、ReactiveX の概念

00:02:25.760 --> 00:02:28.940
全体に実装される
複数のフレームワーク。

00:02:28.940 --> 00:02:35.390
ココ、ジャワ、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# 1の構文でした。

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
aとイベント、私はあなたが見ると思います
それらがすべて行くところ、

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
それは1行のコードか
あなたはそれを書くのを忘れた。

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
なぜなら、1つは、あなたがする必要があります
忘れずに2つのことをする。

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
だから、重要性を行うために
その2番目のもののうち、

00:07:04.040 --> 00:07:05.210
あなたは中にあるすべてが必要です

00:07:05.210 --> 00:07:08.125
あなたの最初の1つを行う
2つ目の全て

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
君は1発だけ解雇したかっただけだ

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
これは私が私と呼ぶものです
IObableインフォマーシャル。

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
これはザマリンフォームじゃない

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
あなたは非常にめったに気にしない
1つのイベントについて。

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
最初の 5 つのイベントをスキップし、

00:09:47.590 --> 00:09:50.050
それから、次の4つだけ気にし、

00:09:50.050 --> 00:09:52.015
その後、イベントをデバウンスします。

00:09:52.015 --> 00:09:56.139
彼らは超高速を入力している場合
2秒待つだけで、

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
ウェブ要求を開始する
そして、彼らはやり直し、

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
だから、IObservableは
しばらくの間、

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
だから違いがある
から 1 つの項目を持つ間

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
したがって、これは反応性から取られます。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
1 対 1 の比較
あなたが反復するとき、そこに。

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 は同等の
基本的に、IObservableに。

00:14:18.085 --> 00:14:19.750
だから、できることは何でも
イエネレータに行う、

00:14:19.750 --> 00:14:21.355
あなたはIObservableにそれを行うことができます。

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
だから効果的に、
次に次のデータを取得します。

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
したがって、これは ReactiveX からも取得されます。

00:16:09.070 --> 00:16:13.030
ここに見ることができるように、
あなたの経過である不可日性、

00:16:13.030 --> 00:16:14.890
それはあなたのIEnumeratorのようなもので、

00:16:14.890 --> 00:16:16.860
あなたは正しい
は IObservable です。

00:16:16.860 --> 00:16:19.150
だから1つはデータを得ることです
ローカル メモリから、

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
トップとあなたは正しい
1 つはネットワークからのもので、

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
の構成要素
ここで少しIObservables。

00:16:50.010 --> 00:16:54.250
だから、これは基本的な考え方です
どのようにIObservableを構築します。

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
コンテナー化できるように、
IObservable内での動作。

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
クリックした上の 1 つ
「よし、

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
例えば、ザマリンフォームのように、

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
テキスト変更されたサブスクリプション,
そして、あなたはそれを処分するだけです。

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
新しい使い捨て原因の割り当て
処分する前の1つは、

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
その1つのイベントとあなただけ
一度見たかった?

00:22:45.445 --> 00:22:48.640
リアクティブを使用すると、

00:22:48.640 --> 00:22:52.045
ここでの全体の概念
この 1 つの式で。

00:22:52.045 --> 00:22:54.160
だから、このすべてが言う、

00:22:54.160 --> 00:22:58.839
「私は1つの値だけを欲しい
このプロパティが変更されました。

00:22:58.839 --> 00:23:02.680
そしてその時点で私は
それを取り除いてほしい」

00:23:02.680 --> 00:23:05.335
だから、それは素晴らしいことだ、

00:23:05.335 --> 00:23:07.555
1つ取ってから切り替えて

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
それで、ここのトップ2は

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
だから、ここでの考えは、
上の2つはデータストリームです。

00:24:19.810 --> 00:24:23.480
そして、一番下の1は
サブスクライバーに表示される内容。

00:24:24.420 --> 00:24:27.519
マージは 2 つのサブスクライバーになります。

00:24:27.519 --> 00:24:29.980
あなたが購読しているかのように
テキスト変更イベントを言うには

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
IEnumerableへのリンクに関して、

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
だから、遅れているのが分かる
1と5の間に2があるので、

00:25:25.840 --> 00:25:27.745
3、および4は

00:25:27.745 --> 00:25:30.280
一緒にとても近くで起こる
その5が今出てくる。

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
キックは嫌い
毎回 Web 要求をオフにする

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
だからテイクは本当にきちんとしているまで、

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
1秒間待つ

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
私は2本の指をやった

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
私たちがエントリを持っているトップ
2 番目のフィールドに対して。

00:31:07.065 --> 00:31:10.320
ユーザーの種類に関しては、
[ログイン] ボタンをクリックします。

00:31:10.320 --> 00:31:12.975
[キャンセル] ボタンをクリックします。
そして、我々はウェブ要求のようなものを持っています。

00:31:12.975 --> 00:31:17.205
だから、私たちは効果的に持っています
5つの異なるイベント。

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
その後、我々は作る
偽の Web 要求呼び出し。

00:32:15.300 --> 00:32:17.670
これは単なるデモンストレーションです。

00:32:17.670 --> 00:32:20.565
本質的にはただの
2 秒待ちます。

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
だから、最初の1つは、私たちです

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
だから今、私たちはこれらの2つを構成しました
観察可能なイベントのアイデア。

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
1つの素敵な小さな場所

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
そして、2つのリスト演算子は、ここで、

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
1 つの操作
私たちはここで示していた。

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
次の 3 つのデータ ポイントがあります。
まさに同じ仕事

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
1 つのデータ ポイントが観測可能です。

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
だから、1つの値を生成します
完了します。

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
もう1回お持ちできますか
質問。違います。分かった、いや

00:44:12.870 --> 00:44:15.075
私はあなたに答えます
直後に質問します。

00:44:15.075 --> 00:44:17.340
クール。ええ シェーンです

00:44:17.340 --> 00:44:20.500
それは私の観察可能です。