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 Forms.

00:00:17.715 --> 00:00:20.280
До того, как быть с формами Xamarin,

00:00:20.280 --> 00:00:23.490
Я работал приличную сумму
с ReactiveUI.

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
около часа? Lol Хорошо.

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
Это было около пяти минут
в разговоре,

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
Так Angular, вероятно,
более синонимом

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
Таким образом, ReactiveX
концепция платформы-агностик.

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
Итак, есть кокос, Java, RxJS.

00:02:35.390 --> 00:02:40.515
Есть целая куча языков
которые реализуют концепции.

00:02:40.515 --> 00:02:45.090
Затем, ReactiveUI является слоем MVVM

00:02:45.090 --> 00:02:48.750
, которая помогает подключить ReactiveX
в ваш MVVM.

00:02:48.750 --> 00:02:52.905
Поэтому, когда люди
говорить о реактивной,

00:02:52.905 --> 00:02:54.705
они не просто говорят
о ReactiveuI.

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
Таким образом, аспект ReactiveX

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- One.

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, есть
событие, ч и событие,

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
Вы получаете стек DOMs.

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
начать веб-запрос
а затем они начинают все сначала,

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
то ReactiveX больше

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
Так что это взято из reactivex. 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 в том, что эквивалентно
в IObservable, в основном.

00:14:18.085 --> 00:14:19.750
Так что все, что вы можете
сделать с IEnumerator,

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
Ссылка на S'L, а затем они были
менее возбужденных по поводу ссылки на S'L,

00:14:31.510 --> 00:14:33.800
но Линк был настолько захватывающим.

00:14:36.960 --> 00:14:41.260
Так эффективно у вас есть
извлеченные данные, которые следующие, onNext.

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
Так, например, веб-запрос.

00:15:14.515 --> 00:15:16.990
Если веб-запрос происходит, и он

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
Таким образом, один получает данные
из местной памяти,

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
строительные блоки
ваши 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
верхний нажал
и говорит: "Хорошо,

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
Итак, у вас есть IDisposable
которые мы все использовали,

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
ReactiveX у вас есть эти вещи
как CompositeDisposable.

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
подписки TextChanged,
а потом вы просто распоряжаться им.

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
Но кто-нибудь здесь сделали
Xamarin Формы вещи?

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
так по ссылке на 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
Таким образом, вы можете видеть, что есть отставание
от одного до пяти, потому что два,

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
Google при вводе
в их Автозаполнении,

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
Тогда TakeUntil является
последний оператор, который я использую,

00:25:56.640 --> 00:25:58.110
так TakeUntil действительно аккуратно,

00:25:58.110 --> 00:26:01.170
потому что это, например,
выглядеть как веб-запрос.

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
если вы не хотите веб-запрос
или что-то подобное, чтобы закончить.

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
Правильно? Так что, если я ударю
"О" есть задержка.

00:28:43.935 --> 00:28:46.170
Таким образом, идея, лежащая в основе
то есть, что вы

00:28:46.170 --> 00:28:49.455
не-это то, что debouncing
о чем ты говоришь.

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
Он запускает веб-запрос, а затем
в этот момент вы можете выйти из системы.

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
Так же, как исключение веб-запроса.

00:29:47.895 --> 00:29:51.630
Тогда он сказал хорошо давайте просто
попробуйте еще раз веб-запрос.

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
ошибка, если некоторые случайные
число равно два.

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
"Войти" и нажав
от "Веб-запрос".

00:33:33.060 --> 00:33:39.090
Так что теперь мы составили эти два
идеи наблюдаемых событий.

00:33:39.090 --> 00:33:42.870
Теперь мы объединили эти данные
поток с выходом.

00:33:42.870 --> 00:33:47.250
Так что, если пользователь нажимает "Logout"
то, что говорит: "Эй,

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 repos.

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
Так, например, сценарии
как async недействительным, например.

00:43:13.500 --> 00:43:16.575
Async пустота не является проблемой
с наблюдаемыми.

00:43:16.575 --> 00:43:18.495
Вам никогда не придется беспокоиться о

00:43:18.495 --> 00:43:21.970
async недействительным, если вы
делать наблюдаемые.

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
Это мои наблюдения.