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
예. 셰인 노이빌. 전 입니다.
자마린 양식 팀과 함께 합니다.

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
그래서 얼마나 많은 사람들이 내가 말하고 있다고 생각
자바 스크립트 및 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
약 한 시간 동안? 아니요. 좋습니다.

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
이 외에 어떤 관계
처음 다섯 글자.

00:01:57.410 --> 00:02:01.105
각도가 시작되었습니다.
RxJS를 많이 사용.

00:02:01.105 --> 00:02:03.260
그래서 각도는 아마
더 동의어

00:02:03.260 --> 00:02:05.870
이 시점에서 RxJS와 함께,하지만 예.

00:02:05.870 --> 00:02:08.810
그런 다음 다음 영역
사람들이 던져지는 곳

00:02:08.810 --> 00:02:12.305
오프는
반응성X 및 리액티브UI,

00:02:12.305 --> 00:02:14.345
그리고 그 분할 포인트가있는 곳.

00:02:14.345 --> 00:02:21.810
그래서 반응X는
플랫폼에 구애받지 않는 개념입니다.

00:02:21.810 --> 00:02:25.760
그래서 반응X 개념

00:02:25.760 --> 00:02:28.940
에서 구현됩니다.
여러 프레임워크를 선택할 수 있습니다.

00:02:28.940 --> 00:02:35.390
그래서 코코, 자바, RxJS가있다.

00:02:35.390 --> 00:02:40.515
언어의 전체 swath있다
개념을 구현합니다.

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
그리고 이벤트, 난 당신이 볼 것 같아요
이 모든 것이 어디로 가고 있는지,

00:04:33.635 --> 00:04:39.080
및 표현
해당 데이터의 현재

00:04:39.080 --> 00:04:41.990
이것이 바로

00:04:41.990 --> 00:04:46.325
이러한 이벤트에 따라 발생했습니다.

00:04:46.325 --> 00:04:49.220
그래서 당신의 이벤트입니다.

00:04:49.220 --> 00:04:51.455
그래서 아무것도 너무 짜릿한
이 시점에서.

00:04:51.455 --> 00:04:55.340
따라서 이벤트 관찰을 중지하는 단계입니다.

00:04:55.340 --> 00:04:58.000
그래서 당신은 어떻게 중지합니까
이벤트를 관찰?

00:04:58.000 --> 00:05:00.600
우리는 모두 관찰되지 않았습니다.
프론트 이벤트, 오른쪽?

00:05:00.600 --> 00:05:01.760
우리 모두가 말했듯이, "이봐, 난 아니에요

00:05:01.760 --> 00:05:03.620
무엇에 대한 더 이상 관심
이런 일이 일어난다."

00:05:03.620 --> 00:05:08.960
그래서 일반적으로, 프로세스
어떻게 알아내는지

00:05:08.960 --> 00:05:11.720
구독 을 취소하려면 이벤트 시작

00:05:11.720 --> 00:05:15.155
고객과 의논
앱이 느리다는 것입니다.

00:05:15.155 --> 00:05:19.070
그래서 고객 파일
"이봐,

00:05:19.070 --> 00:05:21.840
내 응용 프로그램은 그것을 사용 후 속도가 느려집니다.

00:05:22.670 --> 00:05:24.690
무슨 일이 야?

00:05:24.690 --> 00:05:27.075
더 많이 사용할수록,
작동하지 않습니다."

00:05:27.075 --> 00:05:30.550
그래서 먼저, 당신은 그들을 믿지 않습니다.

00:05:31.400 --> 00:05:35.090
당신은 그들이
같은 것을 설치

00:05:35.090 --> 00:05:37.730
복용하는 딜버트 스크린 세이버

00:05:37.730 --> 00:05:39.980
전체 브라우저 창 위로
또는 그런 식으로 뭔가.

00:05:39.980 --> 00:05:42.290
왜냐하면 당신이 시작할 때
응용 프로그램을 최대및

00:05:42.290 --> 00:05:44.795
당신은 그것을 위해 그것을 사용
약 15 초, 그것은 빠릅니다.

00:05:44.795 --> 00:05:46.895
모든 것이 훌륭합니다.
그것은 응답.

00:05:46.895 --> 00:05:51.670
당신은 그것이 완벽하다는 것을 알아 냈습니다.

00:05:51.670 --> 00:05:54.435
그래서, 당신은 같은, "모든
오른쪽. 나는 그들을 믿는 것 같아요."

00:05:54.435 --> 00:05:58.530
그래서이 시점에서, 당신은 먼지
디버깅 모자를 벗고,

00:05:58.530 --> 00:06:01.110
모든 것을 다시 읽습니다.
테스트 및 블로그

00:06:01.110 --> 00:06:04.185
스택 프레임을 분석하려면

00:06:04.185 --> 00:06:06.675
그리고 당신은 모든 것을 당기기 시작합니다.

00:06:06.675 --> 00:06:08.145
스택 DOM을 얻습니다.

00:06:08.145 --> 00:06:10.925
당신은 얼마나 오래 봐
사물이 살아 있다.

00:06:10.925 --> 00:06:13.055
당신은 반복해서 그것을 할.

00:06:13.055 --> 00:06:15.740
마지막으로, 당신은 아래로 지고있어.

00:06:15.740 --> 00:06:18.290
많은 시선이 있습니다.
사물을 가리키는 화살표,

00:06:18.290 --> 00:06:19.940
그리고 어떤 물체가 중요한지 궁금해하며,

00:06:19.940 --> 00:06:22.280
및 이 빼기
그로부터

00:06:22.280 --> 00:06:23.900
마침내 거기에 있는 것을 볼 수 있습니다.

00:06:23.900 --> 00:06:25.595
한 줄의 코드가 나거나
당신은 그것을 쓰는 것을 잊었다.

00:06:25.595 --> 00:06:27.990
"아, 남자."
그때, 갑자기,

00:06:27.990 --> 00:06:30.195
모든 슈퍼 빠른 실행 시작.

00:06:30.195 --> 00:06:33.699
그래서 그래, 내 말은, 기본적으로,

00:06:35.210 --> 00:06:38.280
구독 및 구독 을 취소할 수 있습니다.

00:06:38.280 --> 00:06:43.980
이것이 그것의 의미입니다.

00:06:43.980 --> 00:06:48.345
그러나 의미, 그것은
조금 으스스한 느낌이 듭니다.

00:06:48.345 --> 00:06:52.655
왜냐하면, 당신은
두 가지를 해야 합니다.

00:06:52.655 --> 00:06:55.130
언제 든 지 기억 해야
한 가지 이상의 일을 하기 위해,

00:06:55.130 --> 00:06:57.850
실패할 것입니다.
일반적으로 프로그래밍에 있습니다.

00:06:57.850 --> 00:07:00.695
또한,
모든 것에 대한 귀하의 참조.

00:07:00.695 --> 00:07:04.040
그래서 중요성을 하기 위해
그 두 번째 의,

00:07:04.040 --> 00:07:05.210
모든 것이 필요합니다.

00:07:05.210 --> 00:07:08.125
첫 번째 할 일
두 번째 에 있는 모든 것,

00:07:08.125 --> 00:07:11.930
당신이해야처럼
이러한 아이디어를 유지합니다.

00:07:11.930 --> 00:07:16.725
그래서 일반적인 이벤트 관리
그냥, 그것은 지저분한입니다.

00:07:16.725 --> 00:07:20.015
가장 깨끗한 유형이 아닙니다.
작동할 수 있습니다.

00:07:20.015 --> 00:07:21.290
내 말은, 말하자면,

00:07:21.290 --> 00:07:26.600
당신은 단지에 대한 관심
단일 이벤트(예:

00:07:26.600 --> 00:07:28.465
우리 모두가 이 코드를 작성한 것처럼,

00:07:28.465 --> 00:07:31.340
원하는 경우
같은 것에서 구독 을 취소

00:07:31.340 --> 00:07:35.600
당신은 단지 하나를 발사하고 싶었다.

00:07:35.600 --> 00:07:38.915
그래서 등장 하는 페이지 처럼 가정 해 봅시다
또는 그 자연의 무언가,

00:07:38.915 --> 00:07:42.140
그래서 당신은
상단의 참조

00:07:42.140 --> 00:07:45.830
그래서 폐쇄
내부는 그것에 액세스 할 수 있습니다,

00:07:45.830 --> 00:07:47.975
그런 다음 처리기를 할당하고

00:07:47.975 --> 00:07:50.255
그리고 당신은
끝에 있는 처리기입니다.

00:07:50.255 --> 00:07:55.280
그래서 이 연속적인 의식이 있습니다.

00:07:55.280 --> 00:07:59.150
에서 온다
작업 집합입니다.

00:07:59.150 --> 00:08:03.050
그래서 이것은 익숙한 보인다. 는
모두가 전에이 코드를 작성?

00:08:03.050 --> 00:08:05.790
예? 좋습니다.

00:08:06.930 --> 00:08:12.655
그래서 여기 난 아직도
이벤트에 대해 이야기.

00:08:12.655 --> 00:08:14.860
이것은 내가 내 라고 부르는
아이오서볼인인포머셜.

00:08:14.860 --> 00:08:16.360
당신이 뭔가를 할 곳
미친 그리고 당신은 같은,

00:08:16.360 --> 00:08:17.680
"오 세상에, 정말 끔찍하구나."

00:08:17.680 --> 00:08:22.135
그것은 나쁘지 않다. 하지만 여기
나는 모든 물건을 나타내는거야.

00:08:22.135 --> 00:08:24.115
이것은 자마린 양식이 아닙니다.

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
처음 5개의 이벤트를 건너뛰고

00:09:47.590 --> 00:09:50.050
다음 네 가지에 대해서만 신경을 써서,

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
그래서 그것은 차이
에서 하나의 항목을 갖는 사이에

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
일대일 비교
반복할 때.

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
이에 상응하는 내용
기본적으로 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
예를 들어, 웹 요청.

00:15:14.515 --> 00:15:16.990
웹 요청이 발생하고 웹 요청이 발생하는 경우

00:15:16.990 --> 00:15:20.020
예외를 throw합니다.

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
그래서 당신은 내가 일회용
우리 모두가 사용 했던,

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
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
하지만 여기에 사람이 있다
자마린 양식 물건?

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
1년 전과 같았다고 생각해요.
나는 심지어 다른 것을 사용했다.

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
그래서 당신이 가입한 것처럼
Text변경 된 이벤트를 말하기

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
너무 가까이 에서 일어나고
그 다섯 은 지금 나오는.

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
그런 다음 테이크까지
내가 사용하는 마지막 연산자,

00:25:56.640 --> 00:25:58.110
그래서 테이크 까지 정말 깔끔한,

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
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
어디 한번 봅시다. 노력하고 있어요
여기에 내 윈도우 물건을 할,

00:27:16.300 --> 00:27:20.540
우리가 가서, 나는 그것이 추측하고 있다.

00:27:22.580 --> 00:27:26.610
좋아, 내가 시도했던
패드에 내 제스처.

00:27:26.610 --> 00:27:27.630
나는 스 와이프했다.

00:27:27.630 --> 00:27:28.650
나는 두 손가락을했다,

00:27:28.650 --> 00:27:32.670
나는 이것을했다. 몰라요.

00:27:32.670 --> 00:27:35.280
나는 그것에 일어나지 않았다.

00:27:35.280 --> 00:27:45.015
그래서 우리는 거기에 간다. 좋아, 그래.

00:27:45.015 --> 00:27:46.740
그래서 당신은 창을 시작으로
방금 명중한 곳

00:27:46.740 --> 00:27:48.615
제어하고 분할합니다.

00:27:48.615 --> 00:27:51.910
모든 사람이
그것을 볼 수 있습니다. 좋습니다?

00:27:52.070 --> 00:27:55.410
그래서 내가 데모를 실행하자 진짜

00:27:55.410 --> 00:27:59.895
빠른 그래서 우리는 컨텍스트를 가지고
우리가 여기서 하고 있는 일의.

00:27:59.895 --> 00:28:02.640
그래서 이것은 일종의
기본 응용 프로그램입니다.

00:28:02.640 --> 00:28:08.355
그것은 단지 로그인 로그 아웃 아이디어.

00:28:08.355 --> 00:28:14.265
그래, 그래서 아래 나는 세트가
발생하고 있는 이벤트의

00:28:14.265 --> 00:28:21.690
그래서 이것은 효과적으로
관찰 가능한 데이터 스트림입니다.

00:28:21.690 --> 00:28:23.970
그래서 모든 이벤트는
관찰 가능한 것으로 발생합니다.

00:28:23.970 --> 00:28:25.365
그래서 여기에 우리가 로그인했습니다.

00:28:25.365 --> 00:28:27.240
그래서 이것은 사용자와 암호입니다

00:28:27.240 --> 00:28:28.665
내가 넣어해야한다는 것을
자리 표시자 로그입니다.

00:28:28.665 --> 00:28:34.095
하지만 여기 아이디어는
내가 편지를 쳤는지 볼 수 있습니다.

00:28:34.095 --> 00:28:36.509
저기. 그래서 편지를 명중

00:28:36.509 --> 00:28:39.090
그리고 그 시점에서 그것은
입력의 유효성을 검사합니다.

00:28:39.090 --> 00:28:41.175
지금 당신은 볼 수 있습니다
이 지연의 종류가있다.

00:28:41.175 --> 00:28:43.935
오른쪽? 그래서 내가 명중하는 경우
"O"는 지연이 있습니다.

00:28:43.935 --> 00:28:46.170
그래서 뒤에 아이디어
즉, 당신이

00:28:46.170 --> 00:28:49.455
아니- 그 디바운싱
당신이 얘기하고 있는 것입니다.

00:28:49.455 --> 00:28:54.945
그래서 "사용자 이름"을 입력하면
그리고 "암호".

00:28:54.945 --> 00:28:59.310
저기. 한 번 볼 수 있습니다.
유효성 검사가 수행됩니다.

00:28:59.310 --> 00:29:01.710
그래서 우리는 일종의 휴식의 종류입니다
일단 이 구조물들을 내려놓고

00:29:01.710 --> 00:29:04.275
거기에 도착하지만 그건
그 뒤에 아이디어.

00:29:04.275 --> 00:29:08.910
그래서. 예. 그래서 꽤 흥미 진진한.

00:29:08.910 --> 00:29:11.955
이제 로그인을 위해 시뮬레이션되었습니다.

00:29:11.955 --> 00:29:14.250
그래서 여기에 아이디어는 내가 "로그인"을 클릭합니다.

00:29:14.250 --> 00:29:18.840
웹 요청을 시작한 다음
이 시점에서 로그아웃할 수 있습니다.

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
그것은 본질적으로 단지
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
그래서 첫 번째는 우리

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
사용자가 "로그아웃"을 클릭하면
"이봐,

00:33:47.250 --> 00:33:48.735
로그아웃해 주시길 바랍니다."

00:33:48.735 --> 00:33:54.480
그래서 우리는 전체를 가지고
인증 상태

00:33:54.480 --> 00:34:00.525
다음을 나타내는 응용 프로그램
새로운 관찰 가능한 인증.

00:34:00.525 --> 00:34:02.295
관찰 가능한 인증.

00:34:02.295 --> 00:34:05.295
그래서 유일한 관찰
우리는 이 시점에서 신경을 쓰입니다.

00:34:05.295 --> 00:34:07.530
그래서 지금 우리가 사용할 수있는 방법

00:34:07.530 --> 00:34:09.540
우리가 관찰 할 수있는 다른 곳

00:34:09.540 --> 00:34:14.940
무엇에 대해 물어보고 싶은
인증된 사용자입니다.

00:34:14.940 --> 00:34:18.190
당신은 필요한 것을 알고있다.

00:34:19.910 --> 00:34:22.620
그런 다음 여기에 유효성 검사가 있습니다.

00:34:22.620 --> 00:34:24.720
우리의 검증은

00:34:24.720 --> 00:34:29.410
당사의 사용자 이름과 비밀번호
거기 좋은.

00:34:29.570 --> 00:34:33.645
그래서 본질적으로 온다.

00:34:33.645 --> 00:34:35.894
그것은 말한다 "이봐,

00:34:35.894 --> 00:34:38.909
데이터 포인트는 다음과 같습니다.
타당성을 나타냅니다."

00:34:38.909 --> 00:34:43.080
이러한 이벤트를

00:34:43.080 --> 00:34:47.910
우리가 참또는 거짓 가치
이제 "좋아.

00:34:47.910 --> 00:34:53.860
이벤트의 상태는 무엇입니까?
들어오고있다? "

00:34:55.190 --> 00:34:58.515
그럼 이게 지금 우리가 하자

00:34:58.515 --> 00:35:01.455
함께 넣어 - 지금 우리는 넣을 수 있습니다
이 모든 것들을 함께.

00:35:01.455 --> 00:35:03.120
이것은 일종의
기능처럼

00:35:03.120 --> 00:35:05.295
반응형 프로그래밍 측면
놀이에 온다.

00:35:05.295 --> 00:35:08.880
우리는 이제 이 모든 것을 다른 것으로 만들 수 있습니다.
함께 관찰할 수 있습니다.

00:35:08.880 --> 00:35:10.485
한 좋은 작은 장소

00:35:10.485 --> 00:35:15.255
여기에 모든 것을 설명
그런 일이 일어날 것입니다.

00:35:15.255 --> 00:35:17.760
그래서 이것은 의 일부입니다
정말 깔끔합니다.

00:35:17.760 --> 00:35:22.995
왜냐하면 이것으로
당신이 얻을 수있는 응용 프로그램

00:35:22.995 --> 00:35:27.120
모든 에 대한 원근 범위

00:35:27.120 --> 00:35:31.710
바로 가서만 하는 논리
이 코드 포인트에서 이점을 참조하십시오.

00:35:31.710 --> 00:35:36.060
할 필요가 없습니다.
주위를 뛰어 또는 아무것도.

00:35:36.060 --> 00:35:40.170
그것은 에 따라 불변의 위치

00:35:40.170 --> 00:35:46.485
수정할 수 없는 데이터
이러한 데이터 포인트의 작동 방식입니다.

00:35:46.485 --> 00:35:50.190
그래서 좋은 때문에
그것은 좋은 쉬운 방법입니다.

00:35:50.190 --> 00:35:53.490
그래서 오는 데이터처럼
이 결과 값은 여기

00:35:53.490 --> 00:35:57.450
는 변경할 수 없는 구조입니다.

00:35:57.450 --> 00:36:00.435
그런 다음 이 데이터를 기반으로
인증된 관찰 가능 을 알 수 있습니다.

00:36:00.435 --> 00:36:02.760
그래서 이것이 하는 일
여기에 무엇을 말하고있다

00:36:02.760 --> 00:36:06.315
인증 상태는
인증 여부입니다.

00:36:06.315 --> 00:36:10.845
유효한 여부는
입력한 자격 증명이 유효합니다.

00:36:10.845 --> 00:36:12.360
그런 다음 이를 바탕으로

00:36:12.360 --> 00:36:17.320
가시성을 설정합니다.
응용 프로그램의.

00:36:20.170 --> 00:36:22.890
그래, 그래서 당신은 설정할 수 있습니다
가시성과 같이

00:36:22.890 --> 00:36:26.200
응용 프로그램. 그래서 그것은 깔끔한.

00:36:28.340 --> 00:36:31.905
그럼 보자.

00:36:31.905 --> 00:36:34.350
나는 하나 더 데모 진짜 빠른,

00:36:34.350 --> 00:36:36.820
그냥 작은 하나.

00:36:39.350 --> 00:36:43.725
죄송합니다, 조금 너무 큰
거기. 됐어요.

00:36:43.725 --> 00:36:45.345
모두가 그것을 볼 수 있습니까, 괜찮아?

00:36:45.345 --> 00:36:50.400
예. 좋습니다. 나는 이것들을 가지고 있다.
GitHub 리포지토리처럼 위로 올라가야 합니다.

00:36:50.400 --> 00:36:53.520
이것은 약간의 사용
반응형 UI 물건의,

00:36:53.520 --> 00:36:55.695
하지만 난 그냥 보여 보자.

00:36:55.695 --> 00:37:00.730
이것은 몇 가지 다른 샘플을 가지고
당신이 살펴 볼 수 있습니다.

00:37:02.360 --> 00:37:10.240
바라건대, 그것은 실행됩니다. 그것은
이미 실행 중이시나요? 거기간다.

00:37:10.940 --> 00:37:14.980
그래서 이들의 많은
당신이 보는 간단한 것들.

00:37:15.050 --> 00:37:17.775
살펴봅시다.
위치 데모 이후 우리는

00:37:17.775 --> 00:37:19.905
여기에 시간에 낮은 실행.

00:37:19.905 --> 00:37:21.900
그래서 위치 데모의 아이디어

00:37:21.900 --> 00:37:24.810
그것은 당신이 추적하고 있다는 것입니다
마우스 포인터를 입력합니다.

00:37:24.810 --> 00:37:30.780
이것은 또 다른 인기있는 예가 있습니다.
반응형 개념에 사용할 수 있습니다.

00:37:30.780 --> 00:37:32.055
그래서 당신은 아래로 밀어.

00:37:32.055 --> 00:37:33.660
그것은 당신이 누르는 것을 감지하고 있습니다.

00:37:33.660 --> 00:37:34.740
마우스를 움직이면

00:37:34.740 --> 00:37:36.000
이제 이동한 것을 감지하고 있습니다.

00:37:36.000 --> 00:37:37.380
그리고 당신은 가자, 그것은 제공

00:37:37.380 --> 00:37:40.335
모든 데이터의 집계입니다.

00:37:40.335 --> 00:37:49.380
그것은 조금 깨진

00:37:49.380 --> 00:37:51.720
왜냐하면 나는
설명,

00:37:51.720 --> 00:37:56.080
하지만 정말 깔끔하기 때문에
당신이 정말로해야 할 모든,

00:37:56.120 --> 00:37:58.905
포인터가 이벤트를 눌렀습니다.

00:37:58.905 --> 00:38:01.200
그래서 당신은 포인터를 가지고
말하는 언론,

00:38:01.200 --> 00:38:03.840
"이봐, 마우스를 눌렀어."

00:38:03.840 --> 00:38:06.840
이제, 일단 이
"좋아,

00:38:06.840 --> 00:38:10.395
구독하고 싶습니다.
포인터가 움직입니다."

00:38:10.395 --> 00:38:14.170
그래서 이것은 지금 포인터입니다
이동중입니다.

00:38:14.240 --> 00:38:16.800
지금 움직이고 있는 것처럼,

00:38:16.800 --> 00:38:20.085
이 모든 데이터를 가져오는 경우
여기에 함께,

00:38:20.085 --> 00:38:23.145
그리고 두 목록 연산자, 여기,

00:38:23.145 --> 00:38:24.960
이제
모든 데이터 집계

00:38:24.960 --> 00:38:27.405
단일 데이터 집합으로 함께 변환합니다.

00:38:27.405 --> 00:38:29.760
그런 다음 여기, 그 때까지 테이크는

00:38:29.760 --> 00:38:32.220
하나의 작업
우리는 여기에 보여주고 있었다.

00:38:32.220 --> 00:38:34.170
"이봐, 괜찮아,
난 단지 당신이 원하는

00:38:34.170 --> 00:38:36.270
이 데이터를 가지고
포인터가 공개되었습니다."

00:38:36.270 --> 00:38:38.309
그래서 당신은 이것을 정말로 얻습니다.
멋진 상호 작용

00:38:38.309 --> 00:38:40.020
이 모든 사건들 중에서,

00:38:40.020 --> 00:38:41.940
왜냐하면 당신이 정말로 원했던 모든 것
내가 움직이고 싶다고 말하는 것

00:38:41.940 --> 00:38:44.130
마우스 주위와 때
그들은 마우스를 놓아,

00:38:44.130 --> 00:38:45.810
나는 거기에 있던 모든 데이터를 원한다.

00:38:45.810 --> 00:38:47.160
그래서 당신은이 모든 것을 얻을 수 있습니다

00:38:47.160 --> 00:38:50.505
이 좋은 표현
여기에 작은 가입.

00:38:50.505 --> 00:38:55.120
그래서 이것은
그 주요 예.

00:38:57.130 --> 00:39:03.360
예, 그래서 빠른 프라이머입니다
반응형 개념으로 전환됩니다.

00:39:04.690 --> 00:39:08.940
많은 것들이 있습니다.
좋은 프레임 워크를 밖으로.

00:39:11.210 --> 00:39:16.740
죄송합니다, 도움이되지 않습니다. 됐어요.

00:39:16.740 --> 00:39:23.280
예. 그래서 그 뒤에 아이디어
관찰 가능한 대부분의.

00:39:23.280 --> 00:39:25.530
마이클의 이야기
사용에 대해 좀 더 자세히 알아보기

00:39:25.530 --> 00:39:28.545
MVVM을 가진 이러한 프레임워크.

00:39:28.545 --> 00:39:32.880
정말 강력한 많이있다
동적 데이터와 같은 도구입니다.

00:39:32.880 --> 00:39:35.100
동적 데이터를 선택합니다.

00:39:35.100 --> 00:39:37.590
정말 멋진 플랫폼

00:39:37.590 --> 00:39:41.985
목록에서 초강대국을 위해
관찰할 수 있습니다.

00:39:41.985 --> 00:39:43.890
그래서 아이디어는 당신이 할 수 있다는 것입니다

00:39:43.890 --> 00:39:46.995
본질적으로
모든 것을 관찰 할 수 있습니다.

00:39:46.995 --> 00:39:49.660
서명할 수 있습니다.
나는 그것을 몰랐다.

00:39:51.470 --> 00:39:53.610
그래서 진짜 빠른 것 같아요,

00:39:53.610 --> 00:39:55.960
누구든지 질문이 있습니까?

00:39:57.410 --> 00:40:00.720
예, 샘. 네.

00:40:00.720 --> 00:40:04.095
그냥 가자. 우리는 할게요
35분 동안 질문을 합니다.

00:40:04.095 --> 00:40:05.520
>> 그래서 에 대해 이야기

00:40:05.520 --> 00:40:10.380
공개
[들리지 않는] 그리고 모든 것들.

00:40:10.380 --> 00:40:14.220
관찰 가능한 이유에 대해 이야기하기
더 나은 [들리지]입니다.

00:40:14.220 --> 00:40:20.460
>> 그래, 그래서 나는

00:40:20.460 --> 00:40:24.045
내가 때문에 말할 것 같아요
관리 - 그래서 질문은,

00:40:24.045 --> 00:40:25.680
메모리가 누수되면

00:40:25.680 --> 00:40:28.290
왜 그것이 반환한다는 사실이다

00:40:28.290 --> 00:40:31.245
일회용 더 나은 첫 번째
메모리 관리를 말?

00:40:31.245 --> 00:40:33.090
아이디어는 그냥, 그래,

00:40:33.090 --> 00:40:37.230
그것은 사실이다
그것은 의 일생입니다

00:40:37.230 --> 00:40:43.665
관찰 가능한 측면은
구독합니다.

00:40:43.665 --> 00:40:46.920
그래서 구독할 때
그것에, 당신은 다시 얻을,

00:40:46.920 --> 00:40:49.395
언제 든 지 얻을 수 있기 때문에
뭔가에서 일회용,

00:40:49.395 --> 00:40:51.270
당신은 당신이 알고있다
폐기할 수 있습니다.

00:40:51.270 --> 00:40:54.630
이것이 우리가 사용하는 패러다임입니다.

00:40:54.630 --> 00:40:57.060
그래서 그것에 대 한 아이디어.

00:40:57.060 --> 00:41:01.365
그것은 환기와
특히 새로운 프로그래머의 경우,

00:41:01.365 --> 00:41:03.660
그들은 항상
실수로

00:41:03.660 --> 00:41:07.700
뭔가 같은 곳

00:41:07.700 --> 00:41:08.810
다른 것을 능가하는 것

00:41:08.810 --> 00:41:10.250
왜냐하면 당신은 그것을 이해해야하기 때문입니다.

00:41:10.250 --> 00:41:15.360
그러나 일회용은
아주 기본적인 개념입니다.

00:41:15.360 --> 00:41:19.155
그래서 그 부분으로 데
구독의

00:41:19.155 --> 00:41:22.860
메모리 관리를 만듭니다.
시나리오를 더 쉽게 할 수 있습니다.

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

00:41:25.440 --> 00:41:26.940
다른 질문이 있으십니까?

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

00:41:28.727 --> 00:41:35.250
>> [들리지 않음].

00:41:35.250 --> 00:41:39.060
>> 그렇습니다. 그래서 질문은,

00:41:39.060 --> 00:41:41.985
반응형 프로그래밍을 사용할 수 있습니다.

00:41:41.985 --> 00:41:45.060
작업이나 같은 것들과 함께 또는
비동기 프로그래밍?

00:41:45.060 --> 00:41:50.865
예. 따라서 작업이 효과적으로 수행됩니다.
원포인트 알림입니다.

00:41:50.865 --> 00:41:53.355
그래서 당신은 작업이있을 때,

00:41:53.355 --> 00:41:57.210
에 대한 세 가지 데이터 요소가 있습니다.
정확히 같은 작업

00:41:57.210 --> 00:42:02.175
우리가 표시 할 때 우리의 이터레이터.

00:42:02.175 --> 00:42:05.040
그래서 작업을 작성할 때- 좋아,

00:42:05.040 --> 00:42:06.615
어디에 있는지 모르겠어요.
다가오고 있습니다. 좋습니다.

00:42:06.615 --> 00:42:08.190
그래서 당신은 작업이있을 때,

00:42:08.190 --> 00:42:14.145
작업을 만들 수 있습니다.
당신은 처음에 그것을 가지고,

00:42:14.145 --> 00:42:19.724
그런 다음 작업을 시작합니다.
그래서 지금 실행,

00:42:19.724 --> 00:42:23.355
그런 다음 작업이 값을 생성하고,

00:42:23.355 --> 00:42:26.445
이것이 점 결과입니다.
우리 중 누구도 입력하지 않습니다.

00:42:26.445 --> 00:42:29.970
그리고 나서 완료됩니다.
완료됩니다.

00:42:29.970 --> 00:42:31.440
그래서 그 시점에서,

00:42:31.440 --> 00:42:35.190
하나의 데이터 포인트를 관찰할 수 있습니다.

00:42:35.190 --> 00:42:40.680
그래서 일회용 물건을 만듭니다

00:42:40.680 --> 00:42:42.900
그 작업에 대해 정확히 작동 그래서

00:42:42.900 --> 00:42:45.180
만들 수 있습니다.
작업에 대해 관찰 할 수 있습니다.

00:42:45.180 --> 00:42:49.125
그렇다면 어떤 일이 일어날 지는
당신은 관찰 할 수있는 구독,

00:42:49.125 --> 00:42:54.494
그것은 효과적으로 작업을 시작합니다
그런 일이 발생하면,

00:42:54.494 --> 00:42:56.190
즉, 결과를 다시 차기.

00:42:56.190 --> 00:42:59.655
따라서 하나의 값을 생성합니다.
그리고 완료됩니다.

00:42:59.655 --> 00:43:01.410
그런 다음 또 다른 것입니다.
그건 정말 슈퍼

00:43:01.410 --> 00:43:03.600
해당 작업이 실패하면

00:43:03.600 --> 00:43:05.040
당신은 당신의 물건을 얻을

00:43:05.040 --> 00:43:07.485
관찰 가능한 위치
예외를 catch할 수 있습니다.

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
나는 shhh를 받고 있어요.

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
그건 내 관찰.