WEBVTT

00:00:00.000 --> 00:00:03.190
>> Tudo bem. Olá.
Como estão todos?

00:00:03.380 --> 00:00:08.280
Quarto a caminho através
nossa cúpula XAM aqui.

00:00:08.280 --> 00:00:12.870
Então, sim, eu sou Shane
Neuville. Soletrou direito?

00:00:12.870 --> 00:00:17.715
Sim. Shane Neuville. Eu sou
com a equipe do Xamarin Forms.

00:00:17.715 --> 00:00:20.280
Antes de estar com o Xamarin Forms,

00:00:20.280 --> 00:00:23.490
Eu trabalhei uma quantidade decente
com o ReactiveUI.

00:00:23.490 --> 00:00:26.160
Então eu ainda tento campeão
que tanto quanto eu

00:00:26.160 --> 00:00:29.310
pode até mesmo de dentro da Microsoft.

00:00:29.310 --> 00:00:35.970
Então a conversa aqui vai ser
fortemente sobre extensões reactivas,

00:00:35.970 --> 00:00:39.990
especificamente apenas os conceitos
atrás da unidade reativa,

00:00:39.990 --> 00:00:42.990
como eles perto de eventos.

00:00:42.990 --> 00:00:44.975
Depois, o Michael vai fazer

00:00:44.975 --> 00:00:47.600
uma conversa mais extensa sobre
mapeamento para fora como

00:00:47.600 --> 00:00:52.040
MVVM e como ligar
seus frameworks para isso.

00:00:52.040 --> 00:00:56.055
Então, para nos começar com isso,

00:00:56.055 --> 00:00:59.305
Quantas pessoas usaram
Extensões reactivas,

00:00:59.305 --> 00:01:01.350
apenas para obter, "Oh, Hey. Isso é bom. "?

00:01:01.350 --> 00:01:02.895
Toda vez que eu perguntei,
Há mais mãos.

00:01:02.895 --> 00:01:08.040
Então é um bom sinal. Vamos ver.

00:01:08.040 --> 00:01:12.250
Então, quantas pessoas pensam que eu estou falando
sobre JavaScript e ReactJS?

00:01:12.250 --> 00:01:15.250
Aquele cara ali, ele? Está bem.

00:01:16.130 --> 00:01:20.150
Assim, alguns dos vernáculo
começou a esclarecer-se também.

00:01:20.150 --> 00:01:23.450
Alguém acha que eu vou
falar sobre coleções observáveis

00:01:23.450 --> 00:01:26.940
por cerca de uma hora? Não. Está bem.

00:01:26.940 --> 00:01:29.990
Assim, ao longo disso, este quadro

00:01:29.990 --> 00:01:33.530
torna-se um pouco menos
relevantes como as conversações continuar.

00:01:33.530 --> 00:01:37.580
Havia definitivamente
alguma confusão que começou.

00:01:37.580 --> 00:01:39.980
Então eu me lembro da primeira
vez que ouvi falar de ReactJS.

00:01:39.980 --> 00:01:42.955
Eu estava fazendo RxJS por algum tempo.

00:01:42.955 --> 00:01:45.380
Eram cerca de cinco minutos
na conversa,

00:01:45.380 --> 00:01:48.695
Percebi que não estávamos tendo
a mesma conversa.

00:01:48.695 --> 00:01:51.890
Então não há realmente

00:01:51.890 --> 00:01:55.920
qualquer relação lá além
as primeiras cinco letras.

00:01:57.410 --> 00:02:01.105
O angular começou
fortemente usando RxJS.

00:02:01.105 --> 00:02:03.260
Então angular é provavelmente
mais sinônimo

00:02:03.260 --> 00:02:05.870
com RxJS neste momento, mas sim.

00:02:05.870 --> 00:02:08.810
Então, a próxima área
onde as pessoas são jogadas

00:02:08.810 --> 00:02:12.305
fora tem a ver com o
ReactiveX e ReactiveUI,

00:02:12.305 --> 00:02:14.345
e onde estão os pontos de divisão.

00:02:14.345 --> 00:02:21.810
Assim ReactiveX é
um conceito agnóstico de plataforma.

00:02:21.810 --> 00:02:25.760
Assim, o conceito ReactiveX

00:02:25.760 --> 00:02:28.940
é implementada em
várias estruturas.

00:02:28.940 --> 00:02:35.390
Então, há um coco, um Java, RxJS.

00:02:35.390 --> 00:02:40.515
Há toda uma faixa de línguas
que implementam os conceitos.

00:02:40.515 --> 00:02:45.090
Em seguida, ReactiveUI é a camada MVVM

00:02:45.090 --> 00:02:48.750
que ajuda a ligar o ReactiveX
em seu MVVM.

00:02:48.750 --> 00:02:52.905
Então, quando as pessoas estão
falando sobre reativa,

00:02:52.905 --> 00:02:54.705
Eles não estão apenas falando
sobre ReactiveUI.

00:02:54.705 --> 00:02:55.820
Eles estão falando principalmente sobre

00:02:55.820 --> 00:02:59.090
programação reativa funcional e

00:02:59.090 --> 00:03:02.810
como observável baseado
paradigmas de programação funcionam.

00:03:02.810 --> 00:03:05.870
Assim, o aspecto ReactiveX é

00:03:05.870 --> 00:03:10.655
em grande parte o que esta conversa é
vai girar ao redor,

00:03:10.655 --> 00:03:15.245
que será um bom precursor
para o discurso de Michael mais tarde.

00:03:15.245 --> 00:03:18.830
Então por que me deu um bip?

00:03:18.830 --> 00:03:20.240
Esperar. Eu provavelmente
Talvez eu não tenha

00:03:20.240 --> 00:03:22.845
Destaque. Lá vamos nós.

00:03:22.845 --> 00:03:29.300
Então vamos quebrar o que
Estamos realmente olhando para aqui.

00:03:29.300 --> 00:03:32.420
Então, vamos falar sobre
eventos muito rápidos.

00:03:32.420 --> 00:03:35.570
Então, como você se inscrever para
Eventos? É tudo muito básico.

00:03:35.570 --> 00:03:37.945
Já vimos este código antes.

00:03:37.945 --> 00:03:41.190
Aqui está. Muito excitante, não é?

00:03:41.190 --> 00:03:46.085
Tão eficazmente, você tem
seu editor à esquerda.

00:03:46.085 --> 00:03:48.260
Você tem seus eventos
e então você tem

00:03:48.260 --> 00:03:50.990
seu observador à direita lá.

00:03:50.990 --> 00:03:57.230
Então, é um evento básico
padrão de notificação,

00:03:57.230 --> 00:03:58.760
seu padrão de observador básico.

00:03:58.760 --> 00:04:02.030
Portanto, essa era a sintaxe no C# um.

00:04:02.030 --> 00:04:04.190
Efetivamente, o topo
um faz a mesma coisa

00:04:04.190 --> 00:04:06.395
como o fundo, mas o açúcar sintático.

00:04:06.395 --> 00:04:10.725
Então vamos quebrar o que é um evento.

00:04:10.725 --> 00:04:14.005
Assim, um evento é essencialmente,

00:04:14.005 --> 00:04:21.095
é uma série de coisas individuais
que ocorrem para os dados de produção.

00:04:21.095 --> 00:04:25.260
Então, se eu estou digitando meu nome,

00:04:25.990 --> 00:04:29.930
Eu tipo S, há
um evento, h e evento,

00:04:29.930 --> 00:04:33.635
a e evento, eu acho que você vê
onde todos os que estão indo,

00:04:33.635 --> 00:04:39.080
e a representação
desses dados está aqui.

00:04:39.080 --> 00:04:41.990
Então esse é o conjunto de dados que têm

00:04:41.990 --> 00:04:46.325
ocorreram com base nesses eventos.

00:04:46.325 --> 00:04:49.220
Então esse é o seu evento.

00:04:49.220 --> 00:04:51.455
Então nada muito alucinante
Neste ponto.

00:04:51.455 --> 00:04:55.340
Então, passos para parar de observar um evento.

00:04:55.340 --> 00:04:58.000
Então, como você parar
observando um evento?

00:04:58.000 --> 00:05:00.600
Todos nós não observamos
eventos frontais, certo?

00:05:00.600 --> 00:05:01.760
Como todos nós dissemos, "Ei, eu não

00:05:01.760 --> 00:05:03.620
mais cuidado com o que
Essa coisa acontece. "

00:05:03.620 --> 00:05:08.960
Então, normalmente, o processo
de descobrir como

00:05:08.960 --> 00:05:11.720
para cancelar o evento começa

00:05:11.720 --> 00:05:15.155
com o cliente reclamando
que seu aplicativo é lento.

00:05:15.155 --> 00:05:19.070
Assim, os arquivos do cliente
um problema e diz, "Hey,

00:05:19.070 --> 00:05:21.840
meu aplicativo diminui depois de usá-lo.

00:05:22.670 --> 00:05:24.690
O que se passa?

00:05:24.690 --> 00:05:27.075
Quanto mais eu estou usando,
Não está funcionando. "

00:05:27.075 --> 00:05:30.550
Então, primeiro, você não acredita neles.

00:05:31.400 --> 00:05:35.090
Você acha que eles
algo instalado como

00:05:35.090 --> 00:05:37.730
Dilbert screensaver que está tomando

00:05:37.730 --> 00:05:39.980
a janela inteira do navegador
ou algo parecido.

00:05:39.980 --> 00:05:42.290
Porque quando você começa
seu aplicativo e

00:05:42.290 --> 00:05:44.795
você usá-lo para
cerca de 15 segundos, é rápido.

00:05:44.795 --> 00:05:46.895
Tudo funciona muito bem.
É responsivo.

00:05:46.895 --> 00:05:51.670
Você descobriu que é perfeito.

00:05:51.670 --> 00:05:54.435
Então, você é como, "todos os
Certo. Acho que acredito neles. "

00:05:54.435 --> 00:05:58.530
Então, neste ponto, você poeira
fora de seu chapéu de depuração,

00:05:58.530 --> 00:06:01.110
reler através de todos os
testes e Blogs sobre como

00:06:01.110 --> 00:06:04.185
para analisar quadros de pilha,

00:06:04.185 --> 00:06:06.675
e você começa a puxar tudo.

00:06:06.675 --> 00:06:08.145
Você tem o dom da pilha.

00:06:08.145 --> 00:06:10.925
Você olha quanto tempo
objetos estão vivendo.

00:06:10.925 --> 00:06:13.055
Você faz isso uma e outra vez.

00:06:13.055 --> 00:06:15.740
Finalmente, você está se abaixando.

00:06:15.740 --> 00:06:18.290
Há muitos olhando para
setas apontando para as coisas,

00:06:18.290 --> 00:06:19.940
e querendo saber o que os objetos importam,

00:06:19.940 --> 00:06:22.280
e subtraindo este
de que até que você

00:06:22.280 --> 00:06:23.900
finalmente ver que há

00:06:23.900 --> 00:06:25.595
era que uma linha de código ou
Você esqueceu de escrever isso.

00:06:25.595 --> 00:06:27.990
Você é tipo, "Oh, cara."
Então, de repente,

00:06:27.990 --> 00:06:30.195
Tudo começa a correr super rápido.

00:06:30.195 --> 00:06:33.699
Então, sim, quero dizer, basicamente,

00:06:35.210 --> 00:06:38.280
subscrever e anular a subscrição deles.

00:06:38.280 --> 00:06:43.980
Então essa é a semântica dele.

00:06:43.980 --> 00:06:48.345
Mas a semântica, é
um pouco gnarly eu sinto como.

00:06:48.345 --> 00:06:52.655
Porque um, você tem que
Lembre-se de fazer duas coisas.

00:06:52.655 --> 00:06:55.130
Sempre que tenho que me lembrar
fazer mais do que uma coisa,

00:06:55.130 --> 00:06:57.850
Você vai falhar
geralmente na programação.

00:06:57.850 --> 00:07:00.695
Além disso, você tem que manter
suas referências a tudo.

00:07:00.695 --> 00:07:04.040
Então, a fim de fazer a importância
desse segundo,

00:07:04.040 --> 00:07:05.210
Você precisa de tudo o que está em

00:07:05.210 --> 00:07:08.125
seu primeiro a fazer
tudo no seu segundo,

00:07:08.125 --> 00:07:11.930
como você tem que
manter essas idéias.

00:07:11.930 --> 00:07:16.725
Assim, na gestão geral de eventos
é apenas. é confuso.

00:07:16.725 --> 00:07:20.015
Não é o tipo mais limpo
de operação.

00:07:20.015 --> 00:07:21.290
Quero dizer, como digamos,

00:07:21.290 --> 00:07:26.600
Você só se preocupa com
um único evento, por exemplo,

00:07:26.600 --> 00:07:28.465
como todos nós escrevemos este código,

00:07:28.465 --> 00:07:31.340
onde se você quiser
anular a subscrição de algo como

00:07:31.340 --> 00:07:35.600
Você só queria disparar um.

00:07:35.600 --> 00:07:38.915
Então, digamos, como uma página aparecendo
ou algo dessa natureza,

00:07:38.915 --> 00:07:42.140
Então você tem que ter
a referência no topo

00:07:42.140 --> 00:07:45.830
de modo que o encerramento
dentro tem acesso a ele,

00:07:45.830 --> 00:07:47.975
Então você atribui o manipulador,

00:07:47.975 --> 00:07:50.255
e então você faz
o manipulador no final.

00:07:50.255 --> 00:07:55.280
Então, há uma cerimônia sucessiva

00:07:55.280 --> 00:07:59.150
que vem do
conjunto de operações.

00:07:59.150 --> 00:08:03.050
Então isso parece familiar. É
Todos escreveram este código antes?

00:08:03.050 --> 00:08:05.790
Sim? Está bem.

00:08:06.930 --> 00:08:12.655
Então e aqui eu ainda estou
falando sobre eventos.

00:08:12.655 --> 00:08:14.860
Isto é o que eu chamo de meu
Iobservável infomercial.

00:08:14.860 --> 00:08:16.360
Onde você faz algo
louco e você é como,

00:08:16.360 --> 00:08:17.680
"Oh meu Deus, é tão terrível."

00:08:17.680 --> 00:08:22.135
Não é assim tão mau. Mas aqui
Estou a indicar todas as coisas.

00:08:22.135 --> 00:08:24.115
Isso não é o Xamarin Forms,

00:08:24.115 --> 00:08:26.725
Quando você está fiação até um evento.

00:08:26.725 --> 00:08:29.485
Então você se conectar ao evento,

00:08:29.485 --> 00:08:32.425
Você tem que encontrar bem,
Onde está o meu dispor aspectos?

00:08:32.425 --> 00:08:33.835
Está bem, aqui embaixo.

00:08:33.835 --> 00:08:37.330
Tenho que me certificar de que
eliminar os acontecimentos e

00:08:37.330 --> 00:08:41.350
todas essas coisas está em díspares
locais em todo o seu arquivo.

00:08:41.350 --> 00:08:42.730
Estas são todas essas coisas.

00:08:42.730 --> 00:08:44.290
Esta cerimônia que você tem que fazer

00:08:44.290 --> 00:08:46.240
com todos esses eventos
sistemas de gestão.

00:08:46.240 --> 00:08:48.790
Olhe ali em cima, você
tem que subscrever a ele.

00:08:48.790 --> 00:08:51.385
Então você tem o seu manipulador aqui embaixo.

00:08:51.385 --> 00:08:52.810
Você está lidando com os dados em

00:08:52.810 --> 00:08:55.180
um local separado e
em seguida, se inclina aqui.

00:08:55.180 --> 00:08:59.635
É isso muito
experiência desconectada.

00:08:59.635 --> 00:09:01.240
Então aqui eu até digitei
as coisas erradas,

00:09:01.240 --> 00:09:03.625
Estou tão nervosa com o quanto é difícil.

00:09:03.625 --> 00:09:07.720
Mas, sim. Então eu tenho o infomercial,
para onde foi o refrigerante?

00:09:07.720 --> 00:09:13.225
Então essa é a coisa.

00:09:13.225 --> 00:09:18.175
Assim, os acontecimentos são estes singulares
pontos de dados síncronos.

00:09:18.175 --> 00:09:20.650
Então você recebe uma mudança de texto eventos

00:09:20.650 --> 00:09:22.690
e então tudo que você tem é
Esse evento de alteração de texto.

00:09:22.690 --> 00:09:24.460
Você só tem essa carta.
Você só tem essa carta

00:09:24.460 --> 00:09:27.195
S que você tem que lidar com.

00:09:27.195 --> 00:09:29.145
Mas e se você quiser
fazer mais com isso?

00:09:29.145 --> 00:09:31.200
E se, porque sempre que
Você tem um evento,

00:09:31.200 --> 00:09:33.840
Você muito raramente se importam
sobre o único evento.

00:09:33.840 --> 00:09:36.680
Você se preocupa com os dados
conjunto de eventos.

00:09:36.680 --> 00:09:37.870
Você se preocupa com tudo que é

00:09:37.870 --> 00:09:40.510
acontecendo durante o período de tempo.

00:09:40.510 --> 00:09:43.750
Então, e se você quiser fazer
algo muito excitante.

00:09:43.750 --> 00:09:45.220
Então, e se você quiser dizer,

00:09:45.220 --> 00:09:47.590
Pule seus primeiros cinco eventos e

00:09:47.590 --> 00:09:50.050
Então só se preocupam com os próximos quatro,

00:09:50.050 --> 00:09:52.015
Então você quer debounce os eventos,

00:09:52.015 --> 00:09:56.139
Então, se eles estão digitando super rápido
apenas aguarde dois segundos,

00:09:56.139 --> 00:09:57.610
Então vamos dizer que você quer filtrar

00:09:57.610 --> 00:09:59.215
todos os eventos que são flor de milho azul

00:09:59.215 --> 00:10:02.545
Só porque é uma cor horrível
possivelmente, eu não sei.

00:10:02.545 --> 00:10:05.110
Então você quer

00:10:05.110 --> 00:10:07.120
Kick off o pedido da Web
e então eles começam de mais,

00:10:07.120 --> 00:10:08.860
Então você quer apenas jogar isso fora.

00:10:08.860 --> 00:10:12.220
Como este tipo de padrão é

00:10:12.220 --> 00:10:16.900
muito comum, tanto quanto
sua gestão de eventos,

00:10:16.900 --> 00:10:22.630
especialmente em frameworks MVVM e
coisas que são mais baseadas em interface do usuário.

00:10:22.630 --> 00:10:25.420
Você está sempre tendo que reagir

00:10:25.420 --> 00:10:29.830
contra pontos de dados recebidos
com conectividade ficando perdida.

00:10:29.830 --> 00:10:31.240
Assim como o que se
sua conectividade fica

00:10:31.240 --> 00:10:33.460
perdidos nas solicitações da Web para apontar?

00:10:33.460 --> 00:10:34.870
Como você interrompe

00:10:34.870 --> 00:10:39.745
que a solicitação da Web uma vez
a conectividade é perdida?

00:10:39.745 --> 00:10:48.460
Como você faz isso de forma confiável
que é fácil de gerir.

00:10:48.460 --> 00:10:50.680
Assim, todos estes conceitos têm

00:10:50.680 --> 00:10:58.060
versões muito claras dos verbos
que mapeou-los no reativa.

00:10:58.060 --> 00:10:59.830
Então, estes são todos
coisas reais que você pode

00:10:59.830 --> 00:11:02.590
uso em reativa para articular

00:11:02.590 --> 00:11:07.795
todas essas tentativas sobre seus dados,

00:11:07.795 --> 00:11:09.880
fluxo de eventos ao longo do ano.

00:11:09.880 --> 00:11:13.720
Está bem. Então, o que mais
Podemos fazer com eventos?

00:11:13.720 --> 00:11:19.010
Não muito.
Os padrões básicos muito simples.

00:11:19.260 --> 00:11:23.725
Então essa é a minha lágrima de eventos.

00:11:23.725 --> 00:11:26.110
Então, neste ponto, se
Você não tem realmente usado

00:11:26.110 --> 00:11:28.450
reativa você é provavelmente como,
"Oh, eu tenho sido tão terrível.

00:11:28.450 --> 00:11:31.600
Eu tenho feito isso errado o
todo o tempo ", e você está tendo

00:11:31.600 --> 00:11:33.610
uma crise existencial sobre

00:11:33.610 --> 00:11:37.970
todas as questões que você não
Sei que você tinha que agora você tem.

00:11:39.900 --> 00:11:45.580
Então, vamos traduzir isso
sobre a observables.

00:11:45.580 --> 00:11:48.370
Assim, o IObservable foi
em torno de um tempo.

00:11:48.370 --> 00:11:49.660
É essencialmente como

00:11:49.660 --> 00:11:52.855
um modelo de assinatura de publicação

00:11:52.855 --> 00:11:55.900
que está dentro do núcleo
quadro of.Net e

00:11:55.900 --> 00:11:59.005
em seguida, ReactiveX é mais de

00:11:59.005 --> 00:12:04.465
uma expressão de como interagir
com os observables.

00:12:04.465 --> 00:12:11.245
Então vamos quebrar o que
um observável está aqui.

00:12:11.245 --> 00:12:15.020
Então é essencialmente
um padrão de observador.

00:12:18.690 --> 00:12:21.790
Fundamentalmente, é
a mesma coisa que um evento.

00:12:21.790 --> 00:12:26.000
Um evento é efetivamente
um padrão de observador.

00:12:27.420 --> 00:12:30.775
Então você tem o seu evento aqui,

00:12:30.775 --> 00:12:34.449
seu manipulador e seu editor

00:12:34.449 --> 00:12:37.870
e, em seguida, que é análoga
para isso aqui.

00:12:37.870 --> 00:12:42.865
Então você tem sua observável
que está assistindo,

00:12:42.865 --> 00:12:45.070
sua fazendo a mesma coisa.

00:12:45.070 --> 00:12:47.980
Então você tem a mesma idéia.

00:12:47.980 --> 00:12:51.220
Efetivamente, você pode fazer o exato
mesma coisa com os dois em

00:12:51.220 --> 00:12:54.925
a camada de base e
obter seus pontos de dados.

00:12:54.925 --> 00:12:56.650
Mas a coisa excitante agora,

00:12:56.650 --> 00:12:58.285
Então este é o lugar onde os pontos emocionantes

00:12:58.285 --> 00:13:00.620
de tudo entra em jogo.

00:13:03.690 --> 00:13:07.540
Com um evento, você não
realmente tem alguma coisa.

00:13:07.540 --> 00:13:09.385
Você só tem um evento.

00:13:09.385 --> 00:13:11.770
Mas agora com um observável,

00:13:11.770 --> 00:13:13.510
Você tem uma representação
desse evento.

00:13:13.510 --> 00:13:17.095
Você realmente tem como um objeto de dados
que você pode fazer as coisas com.

00:13:17.095 --> 00:13:22.645
Então é a diferença
entre ter um item de

00:13:22.645 --> 00:13:25.360
uma lista em vez de diferente

00:13:25.360 --> 00:13:28.675
ter dito a lista inteira
que agora você pode operar.

00:13:28.675 --> 00:13:32.140
Então é aí que o seu
diferenças entram em jogo.

00:13:32.140 --> 00:13:35.590
Então você pode pensar no
observável muito

00:13:35.590 --> 00:13:39.550
como o padrão de iterador.

00:13:39.550 --> 00:13:42.340
Então isso é tirado de reactivex. Io

00:13:42.340 --> 00:13:44.485
que é uma das principais fontes,

00:13:44.485 --> 00:13:45.520
que é uma fonte muito boa.

00:13:45.520 --> 00:13:48.100
Tem uma repartição de
todos os seus operadores e tudo mais.

00:13:48.100 --> 00:13:49.930
Então eu tenho um link para ele lá
na parte inferior para você.

00:13:49.930 --> 00:13:56.605
Sim, é efetivamente mapeamento

00:13:56.605 --> 00:14:02.170
sua idéia observável para

00:14:02.170 --> 00:14:03.925
as mesmas coisas que você pode
fazer com um iterador.

00:14:03.925 --> 00:14:05.635
Há quase um perfeito

00:14:05.635 --> 00:14:08.560
comparações um-para-um
lá, quando você iterar.

00:14:08.560 --> 00:14:11.605
Portanto, um iterador é como IEnumerator.

00:14:11.605 --> 00:14:13.945
É o equivalente.

00:14:13.945 --> 00:14:18.085
IEnumerator é o equivalente
para IObservable, basicamente.

00:14:18.085 --> 00:14:19.750
Então, qualquer coisa que você pode
fazer para um IEnumerator,

00:14:19.750 --> 00:14:21.355
Você pode fazê-lo para um IObservable.

00:14:21.355 --> 00:14:23.410
Então isso foi como lembrar
Quando link veio pela primeira vez

00:14:23.410 --> 00:14:25.990
fora e todos foram
super animado sobre

00:14:25.990 --> 00:14:28.225
Link como link sobre objetos e

00:14:28.225 --> 00:14:31.510
Link para SQL e, em seguida, eles foram
menos animado sobre link para SQL,

00:14:31.510 --> 00:14:33.800
Mas link foi tão excitante.

00:14:36.960 --> 00:14:41.260
Tão efetivamente você tem o seu
dados recuperados que é o próximo, onNext.

00:14:41.260 --> 00:14:44.650
Assim como cada um dos seus dados
pontos passam.

00:14:44.650 --> 00:14:47.920
Isso é onde ele pára, tanto quanto onde

00:14:47.920 --> 00:14:52.030
Observables tornam-se mais
excitante do que os seus eventos.

00:14:52.030 --> 00:14:54.550
Então você tem essas outras coisas.

00:14:54.550 --> 00:14:56.875
Então você tem um ar por exemplo.

00:14:56.875 --> 00:15:02.770
Se o seu evento que você está
observando manifesta uma exceção,

00:15:02.770 --> 00:15:05.800
Você pode lidar com isso como
parte do observável.

00:15:05.800 --> 00:15:09.340
Assim como parte do fluxo de dados de
a operação, você pode indicar,

00:15:09.340 --> 00:15:12.970
Hey há este evento
por meio de uma exceção.

00:15:12.970 --> 00:15:14.515
Assim, por exemplo, uma solicitação da Web.

00:15:14.515 --> 00:15:16.990
Se uma solicitação da Web estiver ocorrendo e

00:15:16.990 --> 00:15:20.020
lança uma exceção porque

00:15:20.020 --> 00:15:22.165
a Internet desce ou
algo parecido com isso,

00:15:22.165 --> 00:15:24.850
Então você pode efetivamente pegar esse

00:15:24.850 --> 00:15:28.645
e lidar com isso
dentro desse constructo.

00:15:28.645 --> 00:15:29.920
Por isso torna o seu código muito

00:15:29.920 --> 00:15:35.695
mais robusto e então você
também obter essa idéia de

00:15:35.695 --> 00:15:39.760
conclusão onde você pode disparar se

00:15:39.760 --> 00:15:43.345
Alguém indicou que

00:15:43.345 --> 00:15:45.790
Eles já não se importam
sobre os pontos de dados,

00:15:45.790 --> 00:15:47.725
Você pode então agir sobre isso.

00:15:47.725 --> 00:15:50.590
Todas essas coisas
tornam-se características de

00:15:50.590 --> 00:15:54.070
como você interage com seus dados.

00:15:54.070 --> 00:16:01.760
Então aqui está um pouco mais
pontos de comparação.

00:16:06.120 --> 00:16:09.070
Portanto, isso também é retirado do ReactiveX.

00:16:09.070 --> 00:16:13.030
Como você pode ver aqui, você tem o seu
Iterável que é o seu lapso,

00:16:13.030 --> 00:16:14.890
de modo que é como o seu IEnumerator e

00:16:14.890 --> 00:16:16.860
Você está certo que
é o seu IObservable.

00:16:16.860 --> 00:16:19.150
Então um está recebendo dados
da memória local,

00:16:19.150 --> 00:16:20.210
de modo que vai ser talvez como um

00:16:20.210 --> 00:16:21.890
operação síncrona onde você apenas

00:16:21.890 --> 00:16:23.870
ter seus dados realizados em

00:16:23.870 --> 00:16:26.240
o topo e você está certo
um é da rede,

00:16:26.240 --> 00:16:29.580
pode ser um feed de dados mais lento.

00:16:29.580 --> 00:16:32.915
Então, você pode ver
Você começa essas mesmas idéias

00:16:32.915 --> 00:16:37.350
sobre seus fluxos de eventos que
é apenas, é super poderoso.

00:16:37.870 --> 00:16:42.940
Coisas puras. Está bem.

00:16:42.940 --> 00:16:45.450
Vamos dividir como o

00:16:45.450 --> 00:16:48.610
blocos de construção de
seus IObservables um pouco aqui.

00:16:50.010 --> 00:16:54.250
Então esta é a idéia básica de
como você constrói IObservable.

00:16:54.250 --> 00:16:57.205
Então, como você vê em
que primeiro passo lá,

00:16:57.205 --> 00:17:01.940
Você vê o familiar subscrever
e anular a subscrição,

00:17:03.840 --> 00:17:07.450
Não é tão excitante,
é só passar por

00:17:07.450 --> 00:17:10.390
funções diferentes para o observador,

00:17:10.390 --> 00:17:11.830
para que o observador sabe como lidar

00:17:11.830 --> 00:17:14.185
com assinaturas e Unsubscribes,

00:17:14.185 --> 00:17:18.250
de modo que ele pode conteize que
comportamento dentro do IObservable.

00:17:18.250 --> 00:17:26.185
Então aqui está o comparativo
versões desses,

00:17:26.185 --> 00:17:29.515
do que esses representam.

00:17:29.515 --> 00:17:34.690
Então subscrever é efetivamente
invocando aquele cara de cima,

00:17:34.690 --> 00:17:37.840
o Top um clicou
e dizendo: "Ok,

00:17:37.840 --> 00:17:40.090
Agora eu me importo com meus eventos ", e então

00:17:40.090 --> 00:17:43.000
o fundo um lá
está agora a descartar,

00:17:43.000 --> 00:17:45.715
que é então cancelar a assinatura.

00:17:45.715 --> 00:17:48.730
É aqui que começa
para ficar realmente poderoso,

00:17:48.730 --> 00:17:54.535
Porque você tem
toda esta representação

00:17:54.535 --> 00:17:58.210
é encapsulado em padrão familiar.

00:17:58.210 --> 00:18:01.810
Então você tem IDisposable
que todos nós usamos,

00:18:01.810 --> 00:18:10.080
e temos estruturas de dados lógicos

00:18:10.080 --> 00:18:11.310
e maneiras que podemos usar

00:18:11.310 --> 00:18:14.760
os mais eficazmente do que
apenas dizer cancelar a subscrição.

00:18:14.760 --> 00:18:18.700
Então, alguns muito legal
maneiras que você pode fazer isso,

00:18:18.700 --> 00:18:20.680
Você pode facilmente gerenciar
Estes tempos de vida.

00:18:20.680 --> 00:18:25.359
Então lembre-se antes de onde você tem
para se certificar de cancelar a subscrição,

00:18:25.359 --> 00:18:28.600
assim como no Xamarin Forms, por exemplo,

00:18:28.600 --> 00:18:32.590
Se você está mudando um elemento
ou se algo novo vem

00:18:32.590 --> 00:18:34.210
em que você deseja se inscrever para

00:18:34.210 --> 00:18:36.325
e você não se preocupa com
a coisa mais velha,

00:18:36.325 --> 00:18:40.000
Você tem que fazer essa coisa onde
você cancelar a assinatura do antigo,

00:18:40.000 --> 00:18:41.290
subscrever o novo,

00:18:41.290 --> 00:18:44.920
Então também o seu ponto de descarte tem

00:18:44.920 --> 00:18:48.955
para se certificar de que você está desinscrevendo
desses eventos também.

00:18:48.955 --> 00:18:50.650
Então isso é o que é puro, porém,

00:18:50.650 --> 00:18:57.070
é que todo o seu evento
sistema de gestão de observação

00:18:57.070 --> 00:19:00.055
pode ser articulada
através de produtos descartáveis.

00:19:00.055 --> 00:19:02.740
Agimos para isso e muito
dessas coisas aqui

00:19:02.740 --> 00:19:05.215
Eu gostaria que eles apenas puxar
em the.Net Framework,

00:19:05.215 --> 00:19:08.290
Mas por agora, em

00:19:08.290 --> 00:19:11.440
ReactiveX você tem essas coisas
como Compositedescartável.

00:19:11.440 --> 00:19:13.450
Assim, a idéia de que há
Você pode agregar

00:19:13.450 --> 00:19:17.035
todas as suas descartáveis em
uma única estrutura de dados,

00:19:17.035 --> 00:19:20.260
e então essa estrutura de dados agora,

00:19:20.260 --> 00:19:22.225
Você pode apenas dispor de uma vez,

00:19:22.225 --> 00:19:26.125
uma vez que o tempo de vida
a classe que contém se foi,

00:19:26.125 --> 00:19:28.540
e agora todo o seu evento
gestão é tomado cuidado.

00:19:28.540 --> 00:19:33.310
Assim, você pode anexar o seu
PropertyChanged assinaturas lá,

00:19:33.310 --> 00:19:37.570
suas assinaturas TextChanged,
e então você simplesmente descartá-lo.

00:19:37.570 --> 00:19:38.650
Então é legal porque você está recebendo

00:19:38.650 --> 00:19:44.200
esses conceitos de objeto que
Você pode aplicar aos seus eventos,

00:19:44.200 --> 00:19:48.740
por isso é bom, eu gosto.

00:19:51.900 --> 00:19:55.030
Por exemplo, como eu estava
falando antes,

00:19:55.030 --> 00:19:57.430
Onde você tem uma instância

00:19:57.430 --> 00:19:59.725
Onde você tem um elemento antigo
que você está inscrito,

00:19:59.725 --> 00:20:01.000
Quero dizer, um novo elemento vem

00:20:01.000 --> 00:20:04.690
em que você não se preocupa com
o velho mais.

00:20:04.690 --> 00:20:06.310
Assim tem como estes conceitos frescos

00:20:06.310 --> 00:20:08.110
aqui com como uma eliminação serial,

00:20:08.110 --> 00:20:09.910
onde qualquer coisa que você
atribuir a essa vontade

00:20:09.910 --> 00:20:12.250
automaticamente dispor
da coisa antes.

00:20:12.250 --> 00:20:14.980
Então nessas idéias aqui,

00:20:14.980 --> 00:20:16.900
Você não tem que

00:20:16.900 --> 00:20:19.690
unsubscribe para o que veio em
lá, que é realmente arrumado.

00:20:19.690 --> 00:20:23.530
Mas você sabe que isso é
o novo hotness que você se preocupa com,

00:20:23.530 --> 00:20:25.390
e, em seguida, uma vez que entra,

00:20:25.390 --> 00:20:28.735
Você acabou de se livrar de
o que estava lá antes,

00:20:28.735 --> 00:20:30.370
Então isso permite que você configure

00:20:30.370 --> 00:20:36.470
essas expressões realmente cool
do que você quer fazer.

00:20:37.320 --> 00:20:41.770
Porque um monte de coisas com
Reativa que é muito bom,

00:20:41.770 --> 00:20:47.560
está tendo toda a sua intenção
em um único local.

00:20:47.560 --> 00:20:51.050
O gerenciamento de eventos é
muito callback-based,

00:20:52.080 --> 00:20:56.320
Você não entrar como estilos ruins
como um inferno de retorno de chamada total,

00:20:56.320 --> 00:20:58.645
Mas ainda é gentil
da mesma coisa.

00:20:58.645 --> 00:21:01.330
É o gerenciamento de retorno de chamada
e, em seguida, interagir

00:21:01.330 --> 00:21:03.760
todos estes callback diferente
cenários quando você tem

00:21:03.760 --> 00:21:06.665
a mesma coisa com a forma como você
gerenciar a vida útil dele.

00:21:06.665 --> 00:21:13.470
Mas tem alguém aqui feito
Coisas do Xamarin Forms?

00:21:13.470 --> 00:21:17.050
Estou apenas mapeando
Modelagens lógicos aqui.

00:21:17.050 --> 00:21:20.455
Então você tem essa idéia agora onde

00:21:20.455 --> 00:21:25.690
a maneira que você pode

00:21:25.690 --> 00:21:27.250
gerenciar todo o ciclo de vida de

00:21:27.250 --> 00:21:30.635
algo é apenas direito
lá nessa parte do meio,

00:21:30.635 --> 00:21:33.840
e isso é tudo que você tem que fazer.

00:21:33.840 --> 00:21:36.315
Uma vez que isso é set-up lá,

00:21:36.315 --> 00:21:40.635
Agora a qualquer momento que você entrar e
Você tem uma mudança de elemento,

00:21:40.635 --> 00:21:42.650
e você só se importa
sobre o novo elemento,

00:21:42.650 --> 00:21:47.230
atribuir uma nova causa descartável
o anterior para descartar,

00:21:47.230 --> 00:21:49.990
Então agora todos os seus eventos
são totalmente unwired,

00:21:49.990 --> 00:21:52.645
e então agora você começa
fiação acima de seus novos.

00:21:52.645 --> 00:21:53.860
Então, na sua disposição,

00:21:53.860 --> 00:21:56.260
Você só tem um único
serial Dispose que é

00:21:56.260 --> 00:22:01.750
seu recurso gerenciado de nível de classe
que você está descartando.

00:22:01.750 --> 00:22:06.880
Então, agora não há

00:22:06.880 --> 00:22:10.480
esta complexidade da gestão como
longe como a sua manipulação antecipada.

00:22:10.480 --> 00:22:13.300
Então isso realmente foi
a primeira coisa que me fez

00:22:13.300 --> 00:22:17.630
A programação reativa foi
a gestão descartável,

00:22:18.900 --> 00:22:22.150
Eu acho que foi como um ano antes
Eu até usei qualquer outra coisa.

00:22:22.150 --> 00:22:25.540
Só porque eu tinha um Silverlight
aplicação que estava tendo

00:22:25.540 --> 00:22:30.775
alguns problemas de subscrição e
Então eu aconteceu sobre essas coisas,

00:22:30.775 --> 00:22:32.815
Então esse material é legal,

00:22:32.815 --> 00:22:34.870
os descartáveis me fazem super feliz.

00:22:34.870 --> 00:22:37.390
Então, estes ainda estão mapeando alguns dos

00:22:37.390 --> 00:22:40.120
Estas ideias que são
realmente arrumado, assim como aqui,

00:22:40.120 --> 00:22:42.700
Lembre-se antes quando você
Queria apenas subscrever a

00:22:42.700 --> 00:22:45.445
que um evento e você só
Queria vê-lo uma vez?

00:22:45.445 --> 00:22:48.640
Com reativa, você pode fazer

00:22:48.640 --> 00:22:52.045
que todo o conceito aqui
com esta uma expressão.

00:22:52.045 --> 00:22:54.160
Então tudo isso diz,

00:22:54.160 --> 00:22:58.839
"Eu só quero um valor de
Esta propriedade alterada,

00:22:58.839 --> 00:23:02.680
e, em seguida, nesse ponto eu
Quero que você se livrar dele.

00:23:02.680 --> 00:23:05.335
Então eu quero dizer que é incrível ali,

00:23:05.335 --> 00:23:07.555
Pegue um e depois mude,

00:23:07.555 --> 00:23:10.180
que é um pouco complicado para
entender, mas aqueles são

00:23:10.180 --> 00:23:13.270
apenas razões suficientes
para usá-lo para sempre,

00:23:13.270 --> 00:23:15.340
é bom, eu gosto.

00:23:15.340 --> 00:23:22.210
Então essa é a repartição de
como as operações funcionam.

00:23:22.210 --> 00:23:31.670
Então eu tenho um par de demos de
percebendo isso no código um pouco mais,

00:23:33.360 --> 00:23:39.970
Mas eu queria dar algum conceito
prepará-lo também,

00:23:39.970 --> 00:23:45.700
para alguns dos tipos de reativo
estruturas que estamos usando,

00:23:45.700 --> 00:23:47.980
Só por isso faz um pouco mais de sentido.

00:23:47.980 --> 00:23:50.500
Então, uma das maneiras que você descreve coisas

00:23:50.500 --> 00:23:53.185
com reativa é por
usando diagramas de mármore,

00:23:53.185 --> 00:23:55.075
Então há essas idéias de ver

00:23:55.075 --> 00:24:01.405
sua entrada e qual é a saída.

00:24:01.405 --> 00:24:03.760
Assim, os dois primeiros aqui,

00:24:03.760 --> 00:24:10.285
Este é o vernáculo para
informações mais reativas,

00:24:10.285 --> 00:24:14.800
tão sempre que você vê
Operadores reactivos descritos,

00:24:14.800 --> 00:24:16.330
Eles são sempre descritos
neste formato.

00:24:16.330 --> 00:24:19.810
Então a idéia aqui é que
as duas principais coisas são fluxos de dados,

00:24:19.810 --> 00:24:23.480
e, em seguida, a parte inferior é
o que o assinante vê.

00:24:24.420 --> 00:24:27.519
Merge seria dois assinantes,

00:24:27.519 --> 00:24:29.980
assim como se você estivesse assinando
dizer um evento TextChanged

00:24:29.980 --> 00:24:36.175
em uma caixa de nome de usuário e um
caixa de senha, por exemplo,

00:24:36.175 --> 00:24:38.620
a qualquer momento qualquer um dos
essas mudanças é

00:24:38.620 --> 00:24:40.690
o que sua saída seria parecido.

00:24:40.690 --> 00:24:43.360
Então, estes são alguns dos
os operadores que usei na demo,

00:24:43.360 --> 00:24:44.620
Então eu só queria

00:24:44.620 --> 00:24:50.350
para se certificar de que eles eram
entendido antes de eu me mudar.

00:24:50.350 --> 00:24:53.350
Então Filter, este é
basicamente como um onde,

00:24:53.350 --> 00:24:57.460
assim por diante link para IEnumerable,

00:24:57.460 --> 00:25:00.280
é exatamente como um lugar.

00:25:00.280 --> 00:25:02.260
Tão efetivamente qualquer evento que vem

00:25:02.260 --> 00:25:05.810
através, simples o suficiente para entender.

00:25:05.850 --> 00:25:09.100
Debounce, então este é
o outro recurso muito legal,

00:25:09.100 --> 00:25:11.395
Então isso é estrangular suas entradas.

00:25:11.395 --> 00:25:13.570
Então, neste exemplo, o que eles estão

00:25:13.570 --> 00:25:16.210
demonstrando aqui é
que eles só querem

00:25:16.210 --> 00:25:17.710
o valor mais recente para vir

00:25:17.710 --> 00:25:21.025
Depois de um certo
definir a quantidade de tempo.

00:25:21.025 --> 00:25:25.840
Então você pode ver que há um lag
entre um e cinco porque dois,

00:25:25.840 --> 00:25:27.745
três, e quatro são

00:25:27.745 --> 00:25:30.280
acontecendo tão perto juntos
que cinco está saindo agora.

00:25:30.280 --> 00:25:33.910
Então esta é a quintessência
exemplo de material reactivo,

00:25:33.910 --> 00:25:36.850
casos em que os usuários são

00:25:36.850 --> 00:25:39.400
fazendo como pesquisa com

00:25:39.400 --> 00:25:42.305
Google quando eles estão digitando
em seu AutoComplete,

00:25:42.305 --> 00:25:45.220
Mas você não quer gostar de chutar
uma solicitação da Web de cada vez,

00:25:45.220 --> 00:25:48.640
de modo que é efetivamente o que
Isso está demonstrando,

00:25:48.640 --> 00:25:50.305
que temos um exemplo de.

00:25:50.305 --> 00:25:56.640
Em seguida, TakeUntil é
o último operador que eu uso,

00:25:56.640 --> 00:25:58.110
Então TakeUntil é realmente arrumado,

00:25:58.110 --> 00:26:01.170
Porque isso é, por exemplo,
olhar como um pedido da correia fotorreceptora.

00:26:01.170 --> 00:26:04.605
Então, digamos que um pedido da Web
está começando,

00:26:04.605 --> 00:26:07.210
e, em seguida, o usuário
começa a digitar novamente,

00:26:07.210 --> 00:26:09.880
ou eles dizem cancelar,

00:26:09.880 --> 00:26:11.560
como eles não querem
isso aconteça mais,

00:26:11.560 --> 00:26:16.360
para que todos esses são outro
pontos de evento que você pode promular,

00:26:16.360 --> 00:26:19.465
e nesse ponto ele corta
fora de seu córrego anymore.

00:26:19.465 --> 00:26:22.375
Então isso é como um realmente
maneira simples de dizer cortado,

00:26:22.375 --> 00:26:25.940
Se você não quer um pedido da Web
ou algo parecido para terminar.

00:26:25.940 --> 00:26:32.400
Então esse é o colapso
do material observável,

00:26:32.400 --> 00:26:35.470
Então deixe-me mudar,

00:26:36.080 --> 00:26:39.380
Espere um segundo.

00:26:39.380 --> 00:26:52.660
Legal, vamos ver.

00:26:53.540 --> 00:26:55.875
Isso é muito pequeno?

00:26:55.875 --> 00:26:57.610
>> Sim.

00:26:58.710 --> 00:27:01.330
>> É coisas que você
fazer quando você percebe

00:27:01.330 --> 00:27:04.000
que você nunca fez
Estes sobre as demos antes,

00:27:04.000 --> 00:27:07.525
Na verdade, nunca aumentei
seu tamanho de fonte no Obs Mac antes.

00:27:07.525 --> 00:27:16.300
Vamos ver. Estou tentando
fazer o meu material do Windows aqui,

00:27:16.300 --> 00:27:20.540
lá vamos nós, eu estou supondo que é isso.

00:27:22.580 --> 00:27:26.610
Tudo bem, eu estava tentando
meus gestos no pad.

00:27:26.610 --> 00:27:27.630
Eu fiz o furto.

00:27:27.630 --> 00:27:28.650
Eu fiz dois dedos,

00:27:28.650 --> 00:27:32.670
Eu fiz isso. Eu não sei.

00:27:32.670 --> 00:27:35.280
Eu acho que não aconteceu.

00:27:35.280 --> 00:27:45.015
Então, lá vamos nós. Ok, sim.

00:27:45.015 --> 00:27:46.740
Assim como você iniciar o Windows
Onde você acabou de bater

00:27:46.740 --> 00:27:48.615
controle e dividi-lo.

00:27:48.615 --> 00:27:51.910
Tudo bem para que todos
pode ver isso. Está bem?

00:27:52.070 --> 00:27:55.410
Então deixe-me executar o demo real

00:27:55.410 --> 00:27:59.895
rápido apenas por isso temos contexto
do que estamos fazendo aqui.

00:27:59.895 --> 00:28:02.640
Então este é um tipo de
um aplicativo básico.

00:28:02.640 --> 00:28:08.355
É apenas uma idéia de logout de login.

00:28:08.355 --> 00:28:14.265
Sim, então abaixo eu tenho um conjunto
de eventos que estão ocorrendo,

00:28:14.265 --> 00:28:21.690
Então isso é efetivamente
o fluxo de dados dos observáveis.

00:28:21.690 --> 00:28:23.970
Assim, todos os eventos que são
acontecendo com os observáveis.

00:28:23.970 --> 00:28:25.365
Então, aqui temos login.

00:28:25.365 --> 00:28:27.240
Então, este é usuário e senha

00:28:27.240 --> 00:28:28.665
que eu deveria ter colocado
um log de espaços reservados.

00:28:28.665 --> 00:28:34.095
Mas assim a idéia aqui você
Posso ver se eu bati uma carta.

00:28:34.095 --> 00:28:36.509
Lá. Então bata uma carta

00:28:36.509 --> 00:28:39.090
e nesse ponto é
validar a entrada.

00:28:39.090 --> 00:28:41.175
Agora você pode ver que
Há um tipo de atraso.

00:28:41.175 --> 00:28:43.935
Certo? Então se eu acertar
"O" há um atraso.

00:28:43.935 --> 00:28:46.170
Então a idéia por trás
que é que você está

00:28:46.170 --> 00:28:49.455
Não-isso é que digitais
que você está falando.

00:28:49.455 --> 00:28:54.945
Então, se eu digitar o "username"
e a "password".

00:28:54.945 --> 00:28:59.310
Lá. Você pode ver que uma vez
que a validação acontece.

00:28:59.310 --> 00:29:01.710
Então isso é só nós vamos meio que quebrar
essas estruturas uma vez que eu

00:29:01.710 --> 00:29:04.275
entrar lá, mas isso é
a idéia por trás disso.

00:29:04.275 --> 00:29:08.910
Então. Sim. Muito excitante.

00:29:08.910 --> 00:29:11.955
Agora temos um simulado para login.

00:29:11.955 --> 00:29:14.250
Então, a idéia aqui eu clique em "login".

00:29:14.250 --> 00:29:18.840
Ele inicia uma solicitação da Web e, em seguida,
Nesse ponto, você pode fazer logoff.

00:29:18.840 --> 00:29:21.870
Então, e há uma espécie de

00:29:21.870 --> 00:29:26.415
adicional vamos ver quantas vezes
que leva antes que isso disparadores.

00:29:26.415 --> 00:29:30.090
Então eu tenho um Randomizer
lá para aleatoriamente

00:29:30.090 --> 00:29:35.415
gerar erros. Aqui está.

00:29:35.415 --> 00:29:38.400
Fresco. Então você pode ver aqui o que

00:29:38.400 --> 00:29:41.775
acontece é que eu
clicou no "login".

00:29:41.775 --> 00:29:44.535
Ele gerou uma exceção.

00:29:44.535 --> 00:29:47.895
Assim como a exceção de solicitação da Web.

00:29:47.895 --> 00:29:51.630
Então ele disse ok vamos apenas
Tente novamente a solicitação da Web.

00:29:51.630 --> 00:29:59.640
Então, nesse ponto,
Então me registrou, certo?

00:29:59.640 --> 00:30:02.655
Em seguida, o outro aspecto
deste que sou eu.

00:30:02.655 --> 00:30:05.070
Como digamos que o usuário
Quer cancelá-lo.

00:30:05.070 --> 00:30:09.100
Então, se eles clicam em "login"
Eles podem clicar em "Cancelar".

00:30:09.350 --> 00:30:13.470
Lá você pode ver agora não é
processamento mais longo dos dados.

00:30:13.470 --> 00:30:16.035
Certo? Então isso porque

00:30:16.035 --> 00:30:18.885
Há um tipo de operação
de cancelar isso.

00:30:18.885 --> 00:30:23.805
Então isto é para demo.

00:30:23.805 --> 00:30:25.815
Sim, então esta é a idéia por trás.

00:30:25.815 --> 00:30:27.900
Este é o código.

00:30:27.900 --> 00:30:32.160
Sim, então a idéia

00:30:32.160 --> 00:30:34.965
por trás disso para o tipo de
quebrar as estruturas.

00:30:34.965 --> 00:30:37.935
Desde que todos nós vimos muito
dessas coisas é que

00:30:37.935 --> 00:30:41.340
Esta é a compostabilidade
aspecto dos observáveis.

00:30:41.340 --> 00:30:43.890
O aspecto de compostabilidade
é que você tem

00:30:43.890 --> 00:30:46.920
Essa representação de seus eventos como

00:30:46.920 --> 00:30:50.730
esses fluxos de dados únicos
que você pode então começar a

00:30:50.730 --> 00:30:55.845
Intermix para articular
o comportamento do seu aplicativo.

00:30:55.845 --> 00:31:01.050
Então, se temos o aplicativo que são
todos os fluxos de eventos aqui.

00:31:01.050 --> 00:31:03.360
Os fluxos de eventos são
Temos a entrada em

00:31:03.360 --> 00:31:07.065
no topo temos a entrada
nos segundos campos.

00:31:07.065 --> 00:31:10.320
Como os tipos de usuário que temos
Clique no botão Login.

00:31:10.320 --> 00:31:12.975
Temos o botão Cancelar clique
e temos como o pedido da Web.

00:31:12.975 --> 00:31:17.205
Assim, temos efetivamente
cinco eventos diferentes.

00:31:17.205 --> 00:31:20.550
Fluxos que precisamos descrever.

00:31:20.550 --> 00:31:28.545
Para que possamos quebrá-los
em suas partes reactivas.

00:31:28.545 --> 00:31:32.145
Então, estes são todos muito desanimador.

00:31:32.145 --> 00:31:37.050
Esta é a mesma coisa que você
viu antes que é basicamente

00:31:37.050 --> 00:31:39.180
apenas dizendo Hey eu quero criar este

00:31:39.180 --> 00:31:42.630
observável que está ouvindo
para o evento clicado.

00:31:42.630 --> 00:31:46.095
Então este é o aspecto central
Isso é excitante.

00:31:46.095 --> 00:31:51.825
Assim, criamos um observável para
cada um desses diferentes elementos.

00:31:51.825 --> 00:31:54.030
Temos o nosso login.

00:31:54.030 --> 00:31:55.470
Então é aí que eles clicam.

00:31:55.470 --> 00:31:56.805
Temos o nosso logout.

00:31:56.805 --> 00:31:58.440
É quando eles se registram.

00:31:58.440 --> 00:32:01.785
Temos o nosso cancelamento. Isto é
Quando clicam em "Cancelar".

00:32:01.785 --> 00:32:06.750
Temos a mudança de texto
aqui que é quando eles estão

00:32:06.750 --> 00:32:09.000
digitando o nome de usuário e temos

00:32:09.000 --> 00:32:12.090
a senha aqui quando eles estão
digitando a senha.

00:32:12.090 --> 00:32:15.300
Então, nós fazemos
uma chamada de solicitação da Web falsa.

00:32:15.300 --> 00:32:17.670
Então isso é apenas demonstrar.

00:32:17.670 --> 00:32:20.565
É essencialmente apenas
esperando dois segundos.

00:32:20.565 --> 00:32:22.440
Em seguida, uma vez que termina ele gera

00:32:22.440 --> 00:32:26.265
um erro se algum aleatório
número é igual a dois.

00:32:26.265 --> 00:32:35.010
Sim. Então essa é a nossa candidatura.

00:32:35.010 --> 00:32:38.250
Isso é observável
representação de

00:32:38.250 --> 00:32:41.985
todos os eventos que podem ocorrer
no aplicativo, certo?

00:32:41.985 --> 00:32:43.860
Então, agora é aqui que

00:32:43.860 --> 00:32:47.680
o aspecto composição vem
em jogo que é muito legal.

00:32:48.500 --> 00:32:51.150
Agora, todos estes
observáveis diferentes

00:32:51.150 --> 00:32:53.220
tirar uma vida própria.

00:32:53.220 --> 00:33:00.060
Assim, a totalidade dos
a lógica que você vê

00:33:00.060 --> 00:33:06.990
Há encarnado com um razoavelmente
quantidade simples de código, certo?

00:33:06.990 --> 00:33:12.780
Então aqui este é o nosso código de validação.

00:33:12.780 --> 00:33:14.940
Então agora o que fazemos é
Estamos construindo

00:33:14.940 --> 00:33:18.810
observáveis adicionais em
esses outros observáveis.

00:33:18.810 --> 00:33:21.990
Certo? Então é isso que
o aspecto composição dele.

00:33:21.990 --> 00:33:23.640
Então o primeiro é que

00:33:23.640 --> 00:33:26.520
dizer tudo bem, queremos um
autenticada observável.

00:33:26.520 --> 00:33:29.580
O autenticada observável
é o usuário clicando

00:33:29.580 --> 00:33:33.060
"Login" e clicando em
off "Web Request".

00:33:33.060 --> 00:33:39.090
Então, agora nós compôs estes dois
ideias de eventos observáveis.

00:33:39.090 --> 00:33:42.870
Nós agora mesclamos esses dados
fluxo com um logout.

00:33:42.870 --> 00:33:47.250
Então, se um usuário clica em "Logout"
Então isso está dizendo "Hey,

00:33:47.250 --> 00:33:48.735
Eu quero que você saia.

00:33:48.735 --> 00:33:54.480
Então temos toda a
Estado de autenticação de

00:33:54.480 --> 00:34:00.525
o aplicativo representado por
um novo observável autenticado.

00:34:00.525 --> 00:34:02.295
Autenticado observável.

00:34:02.295 --> 00:34:05.295
Então esse é o único observável
nos preocupamos com este ponto.

00:34:05.295 --> 00:34:07.530
Então é assim que podemos usar isso

00:34:07.530 --> 00:34:09.540
observável em qualquer outro lugar onde nós

00:34:09.540 --> 00:34:14.940
Quer perguntar sobre o que é
o usuário autenticado.

00:34:14.940 --> 00:34:18.190
Você sabe o que é preciso.

00:34:19.910 --> 00:34:22.620
Então aqui temos a nossa validação.

00:34:22.620 --> 00:34:24.720
Nossa validação é uma composição de

00:34:24.720 --> 00:34:29.410
nosso nome de usuário e nossa senha
lá o que é bom.

00:34:29.570 --> 00:34:33.645
Assim que vem essencialmente dentro.

00:34:33.645 --> 00:34:35.894
Diz "Ei,

00:34:35.894 --> 00:34:38.909
Estes são os pontos de dados
que representam a validade. "

00:34:38.909 --> 00:34:43.080
Ele transforma esses eventos em um

00:34:43.080 --> 00:34:47.910
verdadeiro ou um valor falso que
Agora pode usar para dizer: "Ok.

00:34:47.910 --> 00:34:53.860
Qual é o estado dos acontecimentos
que vêm aí? "

00:34:55.190 --> 00:34:58.515
Então vamos nos agora

00:34:58.515 --> 00:35:01.455
juntos-agora podemos colocar
todas essas coisas juntas.

00:35:01.455 --> 00:35:03.120
Este é o lugar onde o tipo de
como o funcional

00:35:03.120 --> 00:35:05.295
aspecto de programação reativa
entra em jogo.

00:35:05.295 --> 00:35:08.880
Agora podemos colocar todos esses diferentes
observáveis juntos em

00:35:08.880 --> 00:35:10.485
um lugar pouco agradável

00:35:10.485 --> 00:35:15.255
aqui que descreve tudo
Isso vai acontecer.

00:35:15.255 --> 00:35:17.760
Então esta é a parte de
que é realmente legal.

00:35:17.760 --> 00:35:22.995
Porque com este
aplicativo que você pode obter

00:35:22.995 --> 00:35:27.120
um âmbito de perspectiva em todos os

00:35:27.120 --> 00:35:31.710
a lógica apenas por estar certo
aqui neste ponto de código.

00:35:31.710 --> 00:35:36.060
Não há necessidade de
saltar ao redor ou qualquer coisa.

00:35:36.060 --> 00:35:40.170
É um local imutável baseado em

00:35:40.170 --> 00:35:46.485
dados imutáveis para modificar
como esses pontos de dados funcionam.

00:35:46.485 --> 00:35:50.190
Então é bom porque
é uma maneira fácil agradável.

00:35:50.190 --> 00:35:53.490
Assim como os dados que vem
neste valor de resultado aqui

00:35:53.490 --> 00:35:57.450
é uma estrutura imutável.

00:35:57.450 --> 00:36:00.435
Em seguida, com base nesses dados, você
Sabe autenticado observável.

00:36:00.435 --> 00:36:02.760
Então o que isso está fazendo
Aqui está dizendo o que é

00:36:02.760 --> 00:36:06.315
seu estado de autenticação é se
Você está autenticado ou não.

00:36:06.315 --> 00:36:10.845
Válido está dizendo se o
credenciais inseridas como são válidas.

00:36:10.845 --> 00:36:12.360
Então, com base nisso,

00:36:12.360 --> 00:36:17.320
Você configura a visibilidade
do seu aplicativo.

00:36:20.170 --> 00:36:22.890
Sim, então você pode configurar
como a visibilidade de

00:36:22.890 --> 00:36:26.200
seu aplicativo. Então está arrumado.

00:36:28.340 --> 00:36:31.905
Então vamos ver.

00:36:31.905 --> 00:36:34.350
Tenho mais uma demo rapidinho,

00:36:34.350 --> 00:36:36.820
apenas um pequeno.

00:36:39.350 --> 00:36:43.725
Oops, um pouco grande demais
Lá. Lá vamos nós.

00:36:43.725 --> 00:36:45.345
Todos vêem isso, certo?

00:36:45.345 --> 00:36:50.400
Sim. Está bem. Eu tenho esses
Como repositórios do GitHub.

00:36:50.400 --> 00:36:53.520
Isso está usando um pouco
do material de UI reativa,

00:36:53.520 --> 00:36:55.695
Mas deixe-me apenas mostrar.

00:36:55.695 --> 00:37:00.730
Isto tem algumas amostras diferentes
que você pode dar uma olhada.

00:37:02.360 --> 00:37:10.240
Esperemos que corra. É
Já está em execução? Aí vai.

00:37:10.940 --> 00:37:14.980
Então, muitos destes são
coisas simples que você vê.

00:37:15.050 --> 00:37:17.775
Vamos olhar para o
demo posição desde que estamos

00:37:17.775 --> 00:37:19.905
ficando com pouca hora aqui.

00:37:19.905 --> 00:37:21.900
Assim, a idéia da posição demo

00:37:21.900 --> 00:37:24.810
é que é você está rastreando
o ponteiro do mouse.

00:37:24.810 --> 00:37:30.780
Isso tem outro exemplo popular
para conceitos reativos.

00:37:30.780 --> 00:37:32.055
Então você empurra para baixo.

00:37:32.055 --> 00:37:33.660
Está detectando que você pressiona.

00:37:33.660 --> 00:37:34.740
Se você mover o mouse ao redor,

00:37:34.740 --> 00:37:36.000
Agora está detectando que você se moveu,

00:37:36.000 --> 00:37:37.380
e então você deixar ir, e dá

00:37:37.380 --> 00:37:40.335
uma agregação de todos os seus dados.

00:37:40.335 --> 00:37:49.380
Está quebrado um pouco

00:37:49.380 --> 00:37:51.720
Porque eu preciso ter
as descrições,

00:37:51.720 --> 00:37:56.080
Mas é realmente puro porque
Tudo que você tem que realmente fazer,

00:37:56.120 --> 00:37:58.905
Você tem o seu ponteiro pressionado evento.

00:37:58.905 --> 00:38:01.200
Então você tem o ponteiro
imprensa que diz,

00:38:01.200 --> 00:38:03.840
"Ei, eu apertei o mouse para baixo."

00:38:03.840 --> 00:38:06.840
Agora, uma vez que isso tem
aconteceu, você diz, "Ok,

00:38:06.840 --> 00:38:10.395
Quero subscrever
o ponteiro que está sendo movido ao redor. "

00:38:10.395 --> 00:38:14.170
Então este é agora o ponteiro
ser movido ao redor.

00:38:14.240 --> 00:38:16.800
Como está se movendo agora,

00:38:16.800 --> 00:38:20.085
Você está puxando todos esses dados
juntos aqui,

00:38:20.085 --> 00:38:23.145
e, em seguida, o operador de duas listas, aqui,

00:38:23.145 --> 00:38:24.960
Agora é capaz de
agregar todos os dados

00:38:24.960 --> 00:38:27.405
juntos em um único conjunto de dados.

00:38:27.405 --> 00:38:29.760
Então aqui, a tomar até que foi

00:38:29.760 --> 00:38:32.220
a única operação que
que estávamos mostrando aqui.

00:38:32.220 --> 00:38:34.170
Ele diz, "Ei, Ok,
Eu só quero que você

00:38:34.170 --> 00:38:36.270
tomar esses dados e dizer
os ponteiros liberados. "

00:38:36.270 --> 00:38:38.309
Então você começa isso realmente
interação cool

00:38:38.309 --> 00:38:40.020
de todos esses acontecimentos para dizer,

00:38:40.020 --> 00:38:41.940
Porque tudo que você realmente queria
dizer é que eu quero mover

00:38:41.940 --> 00:38:44.130
o rato ao redor e quando
Eles deixam ir do mouse,

00:38:44.130 --> 00:38:45.810
Quero todos os dados que estavam lá.

00:38:45.810 --> 00:38:47.160
Então você pode obter tudo isso

00:38:47.160 --> 00:38:50.505
representado neste agradável
pequena subscrição aqui.

00:38:50.505 --> 00:38:55.120
Então este é um dos
Esses exemplos principais.

00:38:57.130 --> 00:39:03.360
Sim, então isso é um primer rápido
nos conceitos reativos.

00:39:04.690 --> 00:39:08.940
Há um monte de
bons frameworks lá fora.

00:39:11.210 --> 00:39:16.740
Opa, não é útil. Lá vamos nós.

00:39:16.740 --> 00:39:23.280
Sim. Então essa é a idéia por trás
a maioria dos observáveis.

00:39:23.280 --> 00:39:25.530
O Michael vai falar
um pouco mais sobre como usar

00:39:25.530 --> 00:39:28.545
essas estruturas com MVVM.

00:39:28.545 --> 00:39:32.880
Há um monte de muito poderoso
ferramentas como dados dinâmicos.

00:39:32.880 --> 00:39:35.100
Selecione dados dinâmicos, é

00:39:35.100 --> 00:39:37.590
uma plataforma muito legal

00:39:37.590 --> 00:39:41.985
para superpotência em suas listas
com observables.

00:39:41.985 --> 00:39:43.890
Então a idéia é que você pode

00:39:43.890 --> 00:39:46.995
essencialmente fazer
tudo e observável.

00:39:46.995 --> 00:39:49.660
Você pode assiná-lo,
Eu não sabia disso.

00:39:51.470 --> 00:39:53.610
Então eu acho muito rápido,

00:39:53.610 --> 00:39:55.960
Alguém tem perguntas?

00:39:57.410 --> 00:40:00.720
Sim, Sam. Bem, sim.

00:40:00.720 --> 00:40:04.095
Vamos só ir lá. Nós vamos
fazer perguntas cerca de 35 minutos.

00:40:04.095 --> 00:40:05.520
>> Então, falar sobre

00:40:05.520 --> 00:40:10.380
a divulgação do
[inaudível] e todas essas coisas.

00:40:10.380 --> 00:40:14.220
Fale sobre por que observáveis
são melhores [inaudível].

00:40:14.220 --> 00:40:20.460
>> Sim, então eu

00:40:20.460 --> 00:40:24.045
Acho que eu diria porque
a gestão-então a questão era,

00:40:24.045 --> 00:40:25.680
com o vazamento de memória,

00:40:25.680 --> 00:40:28.290
Por que é o fato de que ele retorna

00:40:28.290 --> 00:40:31.245
um descartável melhor primeiro
dizer gerenciamento de memória?

00:40:31.245 --> 00:40:33.090
A ideia é que, sim,

00:40:33.090 --> 00:40:37.230
é que é o fato de que
é a vida de

00:40:37.230 --> 00:40:43.665
o observável é um aspecto
da subscrição.

00:40:43.665 --> 00:40:46.920
Então, quando você está assinando
para ele, você voltar,

00:40:46.920 --> 00:40:49.395
Porque sempre que você começa
um descartável de alguma coisa,

00:40:49.395 --> 00:40:51.270
Você sabe que você tem
para eliminá-lo.

00:40:51.270 --> 00:40:54.630
Como esse é o paradigma que usamos.

00:40:54.630 --> 00:40:57.060
Então essa é a idéia sobre isso.

00:40:57.060 --> 00:41:01.365
É que com o desabamento
especialmente para novos programadores,

00:41:01.365 --> 00:41:03.660
Eles estão sempre indo para
fazer isso como erro

00:41:03.660 --> 00:41:07.700
Onde estão como algo

00:41:07.700 --> 00:41:08.810
vai superar outra coisa

00:41:08.810 --> 00:41:10.250
Porque você tem que entender isso.

00:41:10.250 --> 00:41:15.360
Mas um descartável é
um conceito muito básico.

00:41:15.360 --> 00:41:19.155
Então, tendo isso como parte
da subscrição

00:41:19.155 --> 00:41:22.860
faz seu gerenciamento de memória
cenários mais fáceis.

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

00:41:25.440 --> 00:41:26.940
Alguma outra pergunta?

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

00:41:28.727 --> 00:41:35.250
>> [inaudível].

00:41:35.250 --> 00:41:39.060
>> Sim. Então a pergunta era,

00:41:39.060 --> 00:41:41.985
Você pode usar a programação reativa

00:41:41.985 --> 00:41:45.060
com coisas como tarefas ou
programação assíncrona?

00:41:45.060 --> 00:41:50.865
Sim. Assim, uma tarefa é efetivamente
uma notificação de um ponto.

00:41:50.865 --> 00:41:53.355
Então, quando você tem uma tarefa,

00:41:53.355 --> 00:41:57.210
Há três pontos de dados para
uma tarefa que é exatamente como

00:41:57.210 --> 00:42:02.175
nosso iterador quando estávamos indicando.

00:42:02.175 --> 00:42:05.040
Então, quando você escreve uma tarefa-Ok,

00:42:05.040 --> 00:42:06.615
Eu não sei onde é
chegando. Está bem.

00:42:06.615 --> 00:42:08.190
Então, quando você tem uma tarefa,

00:42:08.190 --> 00:42:14.145
você criar a tarefa de modo que é
você tê-lo no início,

00:42:14.145 --> 00:42:19.724
Então você iniciar a tarefa
Então agora está funcionando,

00:42:19.724 --> 00:42:23.355
e, em seguida, a tarefa produz um valor,

00:42:23.355 --> 00:42:26.445
Esse é o seu ponto de resultados
que nenhum de nós está digitando,

00:42:26.445 --> 00:42:29.970
e, em seguida, ele termina em
a conclusão disso.

00:42:29.970 --> 00:42:31.440
Então, nesse ponto,

00:42:31.440 --> 00:42:35.190
Você tem um ponto de dados observável.

00:42:35.190 --> 00:42:40.680
Assim descartável cria coisas

00:42:40.680 --> 00:42:42.900
que funcionam exatamente contra a tarefa de modo

00:42:42.900 --> 00:42:45.180
que você pode criar um
observável contra a tarefa.

00:42:45.180 --> 00:42:49.125
Então o que acontecerá é quando
Você se inscrever para que observável,

00:42:49.125 --> 00:42:54.494
é que vai efetivamente iniciar a tarefa
e então, uma vez que isso aconteça,

00:42:54.494 --> 00:42:56.190
que retrocede um resultado.

00:42:56.190 --> 00:42:59.655
De modo que produza um valor
e, em seguida, ele conclui.

00:42:59.655 --> 00:43:01.410
Então isso é outra coisa
Isso é realmente super

00:43:01.410 --> 00:43:03.600
útil porque se essa tarefa falhar,

00:43:03.600 --> 00:43:05.040
Você começa suas coisas com

00:43:05.040 --> 00:43:07.485
observáveis onde você
pode capturar a exceção.

00:43:07.485 --> 00:43:13.500
Assim, por exemplo, cenários
como Async void, por exemplo.

00:43:13.500 --> 00:43:16.575
Async void é um não-problema
com observables.

00:43:16.575 --> 00:43:18.495
Você nunca tem que se preocupar com

00:43:18.495 --> 00:43:21.970
Async void se você estiver
fazendo observables.

00:43:22.040 --> 00:43:26.520
Então, por exemplo, você sabe como você
Talvez queira iniciar uma tarefa assíncrona

00:43:26.520 --> 00:43:28.050
de um construtor ou coisas como

00:43:28.050 --> 00:43:30.060
que ou essas questões de
aqueles com observáveis,

00:43:30.060 --> 00:43:31.200
Isso nem é um cenário,

00:43:31.200 --> 00:43:34.320
Porque você apenas envolver a tarefa em um

00:43:34.320 --> 00:43:36.180
observável e, em seguida, você tem

00:43:36.180 --> 00:43:39.225
o comportamento de exceção como parte
do observável com a tarefa.

00:43:39.225 --> 00:43:40.710
Então, sim, eles trabalham.

00:43:40.710 --> 00:43:42.060
Eles são ótimos para tarefas.

00:43:42.060 --> 00:43:43.770
Então lá eu esqueço quem faz uma conversa.

00:43:43.770 --> 00:43:46.260
Jeffrey ou algo parecido
que faz uma palestra sobre isso;

00:43:46.260 --> 00:43:48.015
falando sobre como as tarefas são

00:43:48.015 --> 00:43:50.010
Super ruim e você deve
apenas usar observables.

00:43:50.010 --> 00:43:51.360
Mas sim, uma vez que você começar a usar

00:43:51.360 --> 00:43:53.685
observáveis especialmente
em seu código de interface do usuário,

00:43:53.685 --> 00:43:55.260
Você vai efetivamente apenas colocar

00:43:55.260 --> 00:43:57.420
uma fachada na frente de todos os
de suas tarefas porque

00:43:57.420 --> 00:44:02.080
torna-se muito mais simples
gerenciar através de observáveis.

00:44:02.450 --> 00:44:04.905
Alguma outra pergunta?

00:44:04.905 --> 00:44:07.840
Vou pegar o shhh.

00:44:09.380 --> 00:44:12.870
Posso tomar mais uma
Pergunta? Não? Está bem, não.

00:44:12.870 --> 00:44:15.075
Eu responderei ao seu
pergunta logo depois.

00:44:15.075 --> 00:44:17.340
Fresco. Então, sim, eu sou Shane.

00:44:17.340 --> 00:44:20.500
São os meus observáveis.