WEBVTT

00:00:00.000 --> 00:00:03.190
>> Muy bien. Hola.
¿Cómo está todo el mundo?

00:00:03.380 --> 00:00:08.280
Cuarto en el camino a través de
nuestra Cumbre Xam aquí.

00:00:08.280 --> 00:00:12.870
Así que sí, soy Shane
Neuville. ¿Lo deletreó bien?

00:00:12.870 --> 00:00:17.715
Sí. Shane Neuville. Estoy
con el equipo de Xamarin Forms.

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

00:00:20.280 --> 00:00:23.490
Trabajé una cantidad decente
con reactiveUI.

00:00:23.490 --> 00:00:26.160
Así que todavía trato de defender
que tanto como yo

00:00:26.160 --> 00:00:29.310
puede incluso desde dentro de Microsoft.

00:00:29.310 --> 00:00:35.970
Así que la charla aquí va a ser
sobre extensiones reactivas,

00:00:35.970 --> 00:00:39.990
específicamente sólo los conceptos
detrás de la unidad reactiva,

00:00:39.990 --> 00:00:42.990
cómo se acercan a los eventos.

00:00:42.990 --> 00:00:44.975
Luego, Michael va a hacer

00:00:44.975 --> 00:00:47.600
una charla más extensa sobre
mapeo como

00:00:47.600 --> 00:00:52.040
MVVM y cómo alimentar
sus marcos para eso.

00:00:52.040 --> 00:00:56.055
Así que para empezar con esto,

00:00:56.055 --> 00:00:59.305
cuántas personas han utilizado
Extensiones reactivas,

00:00:59.305 --> 00:01:01.350
sólo para conseguir, "Oh, he y. ¿Eso está bien."?

00:01:01.350 --> 00:01:02.895
Cada vez que preguntaba,
hay más manos.

00:01:02.895 --> 00:01:08.040
Así que es una buena señal. Veamos.

00:01:08.040 --> 00:01:12.250
Entonces, ¿cuánta gente piensa que estoy hablando
sobre JavaScript y ReactJS?

00:01:12.250 --> 00:01:15.250
¿Ese tipo de ahí, él? Muy bien.

00:01:16.130 --> 00:01:20.150
Así que algunos de los vernáculos
comenzó a aclararse también.

00:01:20.150 --> 00:01:23.450
¿Alguien cree que voy a
hablar de colecciones observables

00:01:23.450 --> 00:01:26.940
durante aproximadamente una hora? lol Muy bien.

00:01:26.940 --> 00:01:29.990
Así que a lo largo de eso, este marco

00:01:29.990 --> 00:01:33.530
se convierte en un poco menos
relevantes a medida que continúan las conversaciones.

00:01:33.530 --> 00:01:37.580
Definitivamente había
alguna confusión que comenzó.

00:01:37.580 --> 00:01:39.980
Así que recuerdo la primera
tiempo que oí hablar de ReactJS.

00:01:39.980 --> 00:01:42.955
Había estado haciendo RxJS por algún tiempo.

00:01:42.955 --> 00:01:45.380
Fueron unos cinco minutos.
en la conversación,

00:01:45.380 --> 00:01:48.695
Me di cuenta de que no estábamos teniendo
la misma conversación.

00:01:48.695 --> 00:01:51.890
Así que no hay realmente

00:01:51.890 --> 00:01:55.920
cualquier relación allí, además de
las primeras cinco letras.

00:01:57.410 --> 00:02:01.105
El angular ha comenzado
utilizando en gran medida RxJS.

00:02:01.105 --> 00:02:03.260
Así que Angular es probablemente
más sinónimo

00:02:03.260 --> 00:02:05.870
con RxJS en este punto, pero sí.

00:02:05.870 --> 00:02:08.810
Luego, la siguiente área
donde la gente es arrojada

00:02:08.810 --> 00:02:12.305
apagado tiene que ver con el
ReactiveX y ReactiveUI,

00:02:12.305 --> 00:02:14.345
y dónde están esos puntos de división.

00:02:14.345 --> 00:02:21.810
Así que ReactiveX es
un concepto independiente de la plataforma.

00:02:21.810 --> 00:02:25.760
Así que el concepto ReactiveX

00:02:25.760 --> 00:02:28.940
se implementa a través de
múltiples marcos.

00:02:28.940 --> 00:02:35.390
Así que hay un coco, un Java, RxJS.

00:02:35.390 --> 00:02:40.515
Hay toda una franja de idiomas
que implementan los conceptos.

00:02:40.515 --> 00:02:45.090
Entonces, ReactiveUI es la capa MVVM

00:02:45.090 --> 00:02:48.750
que ayuda a conectar ReactiveX
en su MVVM.

00:02:48.750 --> 00:02:52.905
Así que cuando la gente
hablando de Reactivo,

00:02:52.905 --> 00:02:54.705
no sólo están hablando
sobre ReactiveUI.

00:02:54.705 --> 00:02:55.820
Están hablando principalmente de

00:02:55.820 --> 00:02:59.090
programación reactiva funcional y

00:02:59.090 --> 00:03:02.810
cómo observable basado en
los paradigmas de programación funcionan.

00:03:02.810 --> 00:03:05.870
Así que el aspecto ReactiveX es

00:03:05.870 --> 00:03:10.655
en gran medida lo que esta charla es
va a girar alrededor,

00:03:10.655 --> 00:03:15.245
que será un buen precursor
para la charla de Michael más tarde.

00:03:15.245 --> 00:03:18.830
Entonces, ¿por qué me pitó?

00:03:18.830 --> 00:03:20.240
Espera. Probablemente
tal vez no lo tengo

00:03:20.240 --> 00:03:22.845
destacado. Aquí vamos.

00:03:22.845 --> 00:03:29.300
Así que vamos a desglosar lo que
realmente estamos mirando aquí.

00:03:29.300 --> 00:03:32.420
Así que vamos a hablar de
eventos muy rápidos.

00:03:32.420 --> 00:03:35.570
Entonces, ¿cómo te suscribes a
¿Eventos? Todo es bastante básico.

00:03:35.570 --> 00:03:37.945
Todos hemos visto este código antes.

00:03:37.945 --> 00:03:41.190
Aquí tienes. Bastante emocionante, ¿verdad?

00:03:41.190 --> 00:03:46.085
Tan eficazmente, usted tiene
su editor a la izquierda.

00:03:46.085 --> 00:03:48.260
Tienes tus eventos
y luego tienes

00:03:48.260 --> 00:03:50.990
su observador a la derecha.

00:03:50.990 --> 00:03:57.230
Así que, es un evento básico
patrón de notificación,

00:03:57.230 --> 00:03:58.760
su patrón de observador básico.

00:03:58.760 --> 00:04:02.030
Así que esta fue la sintaxis en C.

00:04:02.030 --> 00:04:04.190
Efectivamente, la parte superior
uno hace lo mismo

00:04:04.190 --> 00:04:06.395
como el fondo, pero el azúcar sintáctico.

00:04:06.395 --> 00:04:10.725
Así que vamos a desglosar lo que es un evento.

00:04:10.725 --> 00:04:14.005
Así que un evento es esencialmente,

00:04:14.005 --> 00:04:21.095
es una serie de cosas individuales
que se producen a los datos de producción.

00:04:21.095 --> 00:04:25.260
Así que si estoy escribiendo mi nombre,

00:04:25.990 --> 00:04:29.930
Yo tipo S, hay
un evento, h y evento,

00:04:29.930 --> 00:04:33.635
y el evento, creo que ves
donde van todos,

00:04:33.635 --> 00:04:39.080
y la representación
de esos datos está aquí.

00:04:39.080 --> 00:04:41.990
Así que ese es el conjunto de datos que tienen

00:04:41.990 --> 00:04:46.325
ocurrieron en base a esos eventos.

00:04:46.325 --> 00:04:49.220
Así que ese es tu evento.

00:04:49.220 --> 00:04:51.455
Así que nada demasiado alucinante
en este punto.

00:04:51.455 --> 00:04:55.340
Por lo tanto, los pasos para dejar de observar un evento.

00:04:55.340 --> 00:04:58.000
Entonces, ¿cómo se detiene
observando un evento?

00:04:58.000 --> 00:05:00.600
Todos hemos sido observados
eventos frontales, ¿verdad?

00:05:00.600 --> 00:05:01.760
Como todos hemos dicho, "Oye, yo no

00:05:01.760 --> 00:05:03.620
más tiempo se preocupan por lo que
esto sucede."

00:05:03.620 --> 00:05:08.960
Por lo general, el proceso
de averiguar cómo

00:05:08.960 --> 00:05:11.720
para cancelar la suscripción se inicia el evento

00:05:11.720 --> 00:05:15.155
con el cliente quejándose
que la aplicación es lenta.

00:05:15.155 --> 00:05:19.070
Así que los archivos del cliente
un problema y dice, "Oye,

00:05:19.070 --> 00:05:21.840
mi aplicación se ralentiza después de usarlo.

00:05:22.670 --> 00:05:24.690
¿Qué va mal?

00:05:24.690 --> 00:05:27.075
Cuanto más lo estoy usando,
no está funcionando".

00:05:27.075 --> 00:05:30.550
Así que primero, no les crees.

00:05:31.400 --> 00:05:35.090
¿Crees que han
instalado algo como

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

00:05:37.730 --> 00:05:39.980
hasta toda la ventana del navegador
o algo así.

00:05:39.980 --> 00:05:42.290
Porque cuando empiezas
hasta su solicitud y

00:05:42.290 --> 00:05:44.795
lo usas para
unos 15 segundos, es rápido.

00:05:44.795 --> 00:05:46.895
Todo funciona muy bien.
Es responsivo.

00:05:46.895 --> 00:05:51.670
Ya has descubierto que es perfecto.

00:05:51.670 --> 00:05:54.435
Entonces, usted está como, "Todos
Correcto. Supongo que les creo.

00:05:54.435 --> 00:05:58.530
Así que en este punto, el polvo
de su sombrero de depuración,

00:05:58.530 --> 00:06:01.110
releer a través de todos los
pruebas y blogs sobre cómo

00:06:01.110 --> 00:06:04.185
para analizar marcos de pila,

00:06:04.185 --> 00:06:06.675
y empiezas a tirar de todo.

00:06:06.675 --> 00:06:08.145
Obtiene los DOM de pila.

00:06:08.145 --> 00:06:10.925
Miras cuánto tiempo
objetos están vivos.

00:06:10.925 --> 00:06:13.055
Lo haces una y otra vez.

00:06:13.055 --> 00:06:15.740
Finalmente, te vas a bajar.

00:06:15.740 --> 00:06:18.290
Hay un montón de mirar
flechas apuntando a las cosas,

00:06:18.290 --> 00:06:19.940
y preguntándose qué objetos importan,

00:06:19.940 --> 00:06:22.280
y restando este
desde que hasta que

00:06:22.280 --> 00:06:23.900
finalmente ver que hay

00:06:23.900 --> 00:06:25.595
era que una línea de código o
olvidaste escribir eso.

00:06:25.595 --> 00:06:27.990
Estás como, "Oh, hombre."
Entonces, de repente,

00:06:27.990 --> 00:06:30.195
todo empieza a funcionar muy rápido.

00:06:30.195 --> 00:06:33.699
Así que sí, quiero decir, básicamente,

00:06:35.210 --> 00:06:38.280
suscribirse y darse de baja de ellos.

00:06:38.280 --> 00:06:43.980
Así que esa es la semántica de la misma.

00:06:43.980 --> 00:06:48.345
Pero la semántica, es
un poco gruñón que me siento como.

00:06:48.345 --> 00:06:52.655
Porque uno, tienes que
recuerde hacer dos cosas.

00:06:52.655 --> 00:06:55.130
Cada vez que tengo que recordar
para hacer más de una cosa,

00:06:55.130 --> 00:06:57.850
vas a fallar
por lo general en la programación.

00:06:57.850 --> 00:07:00.695
Además, usted tiene que retener
sus referencias a todo.

00:07:00.695 --> 00:07:04.040
Así que con el fin de hacer la importancia
de ese segundo,

00:07:04.040 --> 00:07:05.210
necesitas todo lo que hay en

00:07:05.210 --> 00:07:08.125
el primero en hacer
todo en el segundo,

00:07:08.125 --> 00:07:11.930
como usted tiene que
mantener esas ideas.

00:07:11.930 --> 00:07:16.725
Así que en la gestión general de eventos
es sólo que.es desordenado.

00:07:16.725 --> 00:07:20.015
No es el tipo más limpio
de funcionamiento.

00:07:20.015 --> 00:07:21.290
Quiero decir, como digamos,

00:07:21.290 --> 00:07:26.600
sólo te importa
un solo evento, por ejemplo,

00:07:26.600 --> 00:07:28.465
como si todos lo hiciéramos,

00:07:28.465 --> 00:07:31.340
donde si quieres
darse de baja de algo como

00:07:31.340 --> 00:07:35.600
sólo querías disparar a uno.

00:07:35.600 --> 00:07:38.915
Así que digamos, como una página que aparece
o algo de esa naturaleza,

00:07:38.915 --> 00:07:42.140
por lo que tiene que tener
la referencia en la parte superior

00:07:42.140 --> 00:07:45.830
para que el cierre
dentro tiene acceso a ella,

00:07:45.830 --> 00:07:47.975
a continuación, se asigna el controlador,

00:07:47.975 --> 00:07:50.255
y luego lo haces
el manejador al final.

00:07:50.255 --> 00:07:55.280
Así que hay una ceremonia sucesiva

00:07:55.280 --> 00:07:59.150
que proviene de la
conjunto de operaciones.

00:07:59.150 --> 00:08:03.050
Así que esto me resulta familiar. Es
todo el mundo escribió este código antes?

00:08:03.050 --> 00:08:05.790
¿Sí? Muy bien.

00:08:06.930 --> 00:08:12.655
Así que y aquí todavía estoy
hablando de eventos.

00:08:12.655 --> 00:08:14.860
Esto es lo que yo llamo mi
IObservable Infomercial.

00:08:14.860 --> 00:08:16.360
Donde haces algo
loco y estás como,

00:08:16.360 --> 00:08:17.680
"Oh Dios mío, es tan terrible."

00:08:17.680 --> 00:08:22.135
No es tan malo. Pero aquí
Estoy indicando todas las cosas.

00:08:22.135 --> 00:08:24.115
Esto no es Xamarin Forms,

00:08:24.115 --> 00:08:26.725
cuando estás conectando un evento.

00:08:26.725 --> 00:08:29.485
Así que conectas al evento,

00:08:29.485 --> 00:08:32.425
tienes que encontrar bien,
¿dónde están mis aspectos de disposición?

00:08:32.425 --> 00:08:33.835
Está bien, está aquí abajo.

00:08:33.835 --> 00:08:37.330
Tengo que asegurarme de
disponer de los eventos y

00:08:37.330 --> 00:08:41.350
todo esto es en dispar
ubicaciones en todo el archivo.

00:08:41.350 --> 00:08:42.730
Estas son todas estas cosas.

00:08:42.730 --> 00:08:44.290
Esta ceremonia que tienes que hacer

00:08:44.290 --> 00:08:46.240
con todo este evento
sistemas de gestión.

00:08:46.240 --> 00:08:48.790
Mira ahí arriba, tú
tienen que suscribirse a ella.

00:08:48.790 --> 00:08:51.385
Entonces tienes a tu manejador aquí abajo.

00:08:51.385 --> 00:08:52.810
Usted está tratando con los datos en

00:08:52.810 --> 00:08:55.180
un lugar separado y
luego se dobla aquí.

00:08:55.180 --> 00:08:59.635
Es esto muy
experiencia desconectada.

00:08:59.635 --> 00:09:01.240
Así que aquí incluso mecanografié
las cosas equivocadas,

00:09:01.240 --> 00:09:03.625
Estoy tan nervioso por lo difícil que es.

00:09:03.625 --> 00:09:07.720
Pero sí. Así que conseguí el infomercial,
¿adónde fue el refresco?

00:09:07.720 --> 00:09:13.225
Así que esa es la cuestión.

00:09:13.225 --> 00:09:18.175
Así que los eventos son estos singulares
puntos de datos sincrónicos.

00:09:18.175 --> 00:09:20.650
Así que obtienes un cambio de texto eventos

00:09:20.650 --> 00:09:22.690
y luego todo lo que tienes es
ese evento de cambio de texto.

00:09:22.690 --> 00:09:24.460
Sólo tienes esa carta.
Sólo tienes esa carta.

00:09:24.460 --> 00:09:27.195
S que tienes que lidiar con.

00:09:27.195 --> 00:09:29.145
Pero, ¿y si quieres
para hacer más con eso?

00:09:29.145 --> 00:09:31.200
¿Qué pasa si, porque siempre que
tienes un evento,

00:09:31.200 --> 00:09:33.840
muy rara vez te importa
sobre el único evento.

00:09:33.840 --> 00:09:36.680
Te importan los datos
conjunto de eventos.

00:09:36.680 --> 00:09:37.870
Te preocupas por todo lo que es

00:09:37.870 --> 00:09:40.510
durante el período de tiempo.

00:09:40.510 --> 00:09:43.750
¿Y si quieres hacer
algo muy emocionante.

00:09:43.750 --> 00:09:45.220
¿Y si quieres decir,

00:09:45.220 --> 00:09:47.590
omita sus primeros cinco eventos y

00:09:47.590 --> 00:09:50.050
entonces sólo se preocupan por los próximos cuatro,

00:09:50.050 --> 00:09:52.015
entonces quieres eliminar los eventos,

00:09:52.015 --> 00:09:56.139
así que si están escribiendo súper rápido
sólo esperar dos segundos,

00:09:56.139 --> 00:09:57.610
entonces digamos que desea filtrar

00:09:57.610 --> 00:09:59.215
cualquier evento que sea azul flor de maíz

00:09:59.215 --> 00:10:02.545
sólo porque es un color horrible
posiblemente, no lo sé.

00:10:02.545 --> 00:10:05.110
Entonces quieres

00:10:05.110 --> 00:10:07.120
iniciar la solicitud web
y luego empiezan de nuevo,

00:10:07.120 --> 00:10:08.860
así que quieres tirar eso.

00:10:08.860 --> 00:10:12.220
Como este tipo de patrón es

00:10:12.220 --> 00:10:16.900
muy común en cuanto a
su gestión de eventos,

00:10:16.900 --> 00:10:22.630
especialmente en los marcos MVVM y
cosas que se basan más en la interfaz de usuario.

00:10:22.630 --> 00:10:25.420
Siempre tienes que reaccionar

00:10:25.420 --> 00:10:29.830
contra los puntos de datos entrantes
con la conectividad perdándose.

00:10:29.830 --> 00:10:31.240
Así que como ¿qué pasaría si
su conectividad se pone

00:10:31.240 --> 00:10:33.460
perdido en las solicitudes web para señalar?

00:10:33.460 --> 00:10:34.870
¿Cómo se interrumpe

00:10:34.870 --> 00:10:39.745
esa solicitud web una vez
la conectividad se pierde?

00:10:39.745 --> 00:10:48.460
¿Cómo se hace eso de una manera confiable
que es fácil de manejar.

00:10:48.460 --> 00:10:50.680
Así que todos estos conceptos tienen

00:10:50.680 --> 00:10:58.060
versiones muy claras de los verbos
que los mapeó en el reactivo.

00:10:58.060 --> 00:10:59.830
Así que estos son todos
cosas reales que se pueden

00:10:59.830 --> 00:11:02.590
uso reactivo para articular

00:11:02.590 --> 00:11:07.795
todos estos intentos sobre sus datos,

00:11:07.795 --> 00:11:09.880
transmisión de eventos durante el año.

00:11:09.880 --> 00:11:13.720
Muy bien. Entonces, ¿qué más
podemos hacer con eventos?

00:11:13.720 --> 00:11:19.010
En realidad no tanto.
Los patrones básicos muy simples.

00:11:19.260 --> 00:11:23.725
Así que esa es mi desmontaje de los eventos.

00:11:23.725 --> 00:11:26.110
Así que en este punto, si
que realmente no ha utilizado

00:11:26.110 --> 00:11:28.450
reactivo que probablemente seas como,
"Oh, he sido tan terrible.

00:11:28.450 --> 00:11:31.600
He estado haciendo esto mal el
todo el tiempo", y usted está teniendo

00:11:31.600 --> 00:11:33.610
una crisis existencial sobre

00:11:33.610 --> 00:11:37.970
todos los problemas que no
saber que tenía que ahora que tiene.

00:11:39.900 --> 00:11:45.580
Así que vamos a traducir esto
a Observables.

00:11:45.580 --> 00:11:48.370
Así que IObservable ha sido
alrededor por un tiempo.

00:11:48.370 --> 00:11:49.660
Es esencialmente como

00:11:49.660 --> 00:11:52.855
un modelo de suscripción de publicación

00:11:52.855 --> 00:11:55.900
que está dentro del núcleo
marco of.Net y

00:11:55.900 --> 00:11:59.005
entonces ReactiveX es más de

00:11:59.005 --> 00:12:04.465
una expresión de cómo interactuar
con esos Observables.

00:12:04.465 --> 00:12:11.245
Así que vamos a desglosar lo que
un Observable está aquí.

00:12:11.245 --> 00:12:15.020
Así que es esencialmente
un patrón de observador.

00:12:18.690 --> 00:12:21.790
Fundamentalmente, es
lo mismo que un evento.

00:12:21.790 --> 00:12:26.000
Un evento es efectivamente
un patrón de observador.

00:12:27.420 --> 00:12:30.775
Así que tienen su evento aquí,

00:12:30.775 --> 00:12:34.449
su manejador y su editor

00:12:34.449 --> 00:12:37.870
y luego eso es análogo
a esto aquí.

00:12:37.870 --> 00:12:42.865
Así que usted tiene su observable
que está mirando,

00:12:42.865 --> 00:12:45.070
está haciendo lo mismo.

00:12:45.070 --> 00:12:47.980
Así que tienes la misma idea.

00:12:47.980 --> 00:12:51.220
Efectivamente, usted puede hacer el
lo mismo con los dos de los

00:12:51.220 --> 00:12:54.925
la capa base y
obtener sus puntos de datos.

00:12:54.925 --> 00:12:56.650
Pero lo emocionante ahora,

00:12:56.650 --> 00:12:58.285
así que aquí es donde los puntos emocionantes

00:12:58.285 --> 00:13:00.620
de todo entra en juego.

00:13:03.690 --> 00:13:07.540
Con un evento, no
realmente tienen nada.

00:13:07.540 --> 00:13:09.385
Sólo tienes un evento.

00:13:09.385 --> 00:13:11.770
Pero ahora con un observable,

00:13:11.770 --> 00:13:13.510
usted tiene una representación
de ese evento.

00:13:13.510 --> 00:13:17.095
En realidad tienes como un objeto de datos
que puedes hacer cosas con.

00:13:17.095 --> 00:13:22.645
Así que es la diferencia
entre tener un elemento de

00:13:22.645 --> 00:13:25.360
una lista en lugar de que no sea

00:13:25.360 --> 00:13:28.675
haber dicho toda la lista
que ahora se puede operar más.

00:13:28.675 --> 00:13:32.140
Así que ahí es donde su
diferencias entran en juego.

00:13:32.140 --> 00:13:35.590
Así que usted puede pensar en el
observable mucho

00:13:35.590 --> 00:13:39.550
como el patrón de iterador.

00:13:39.550 --> 00:13:42.340
Así que esto se toma de reactivex. Io

00:13:42.340 --> 00:13:44.485
que es una de las principales fuentes,

00:13:44.485 --> 00:13:45.520
que es una muy buena fuente.

00:13:45.520 --> 00:13:48.100
Tiene un desglose de
todos sus operadores y todo.

00:13:48.100 --> 00:13:49.930
Así que tengo un enlace a él allí
en el fondo para usted.

00:13:49.930 --> 00:13:56.605
sí, es efectivamente mapeo

00:13:56.605 --> 00:14:02.170
su idea observable para

00:14:02.170 --> 00:14:03.925
las mismas cosas que puedes
hacer con un iterador.

00:14:03.925 --> 00:14:05.635
Hay casi un perfecto

00:14:05.635 --> 00:14:08.560
comparaciones uno a uno
allí, cuando itera.

00:14:08.560 --> 00:14:11.605
Así que un iterador es como IEnumerator.

00:14:11.605 --> 00:14:13.945
Ese es el equivalente.

00:14:13.945 --> 00:14:18.085
IEnumerator es lo que es equivalente
a IObservable, básicamente.

00:14:18.085 --> 00:14:19.750
Así que cualquier cosa que puedas
hacer a un IEnumerator,

00:14:19.750 --> 00:14:21.355
se puede hacer a un IObservable.

00:14:21.355 --> 00:14:23.410
Así que eso fue como recordar
cuando Link llegó por primera vez

00:14:23.410 --> 00:14:25.990
fuera y todo el mundo estaba
super emocionado por

00:14:25.990 --> 00:14:28.225
Enlace como Enlace sobre objetos y

00:14:28.225 --> 00:14:31.510
Enlace a SQL y luego fueron
menos entusiasmado con Link to SQL,

00:14:31.510 --> 00:14:33.800
pero Link fue tan emocionante.

00:14:36.960 --> 00:14:41.260
Tan eficazmente usted tiene su
datos recuperados que es siguiente, onNext.

00:14:41.260 --> 00:14:44.650
Así que como cada uno de sus datos
puntos vienen a través.

00:14:44.650 --> 00:14:47.920
Ahí es donde se detiene hasta donde

00:14:47.920 --> 00:14:52.030
Los observatorios se vuelven más
emocionante que sus eventos.

00:14:52.030 --> 00:14:54.550
Así que tienes estas otras cosas.

00:14:54.550 --> 00:14:56.875
Así que usted consigue un aire, por ejemplo.

00:14:56.875 --> 00:15:02.770
Si su evento que usted es
observando manifiestos una excepción,

00:15:02.770 --> 00:15:05.800
usted puede lidiar con eso como
parte de lo observable.

00:15:05.800 --> 00:15:09.340
Así que como parte del flujo de datos de
la operación, se puede indicar,

00:15:09.340 --> 00:15:12.970
he y hay este evento
a través de una excepción.

00:15:12.970 --> 00:15:14.515
Así, por ejemplo, una solicitud web.

00:15:14.515 --> 00:15:16.990
Si se está produciendo una solicitud web y

00:15:16.990 --> 00:15:20.020
lanza una excepción porque

00:15:20.020 --> 00:15:22.165
Internet se cae o
algo similar a eso,

00:15:22.165 --> 00:15:24.850
entonces usted puede efectivamente coger que

00:15:24.850 --> 00:15:28.645
y lidiar con eso
dentro de esa construcción.

00:15:28.645 --> 00:15:29.920
Así que hace que su código mucho

00:15:29.920 --> 00:15:35.695
más robusto y luego que
también tener esta idea de

00:15:35.695 --> 00:15:39.760
finalización donde se puede disparar si

00:15:39.760 --> 00:15:43.345
alguien ha indicado que

00:15:43.345 --> 00:15:45.790
ya no les importa
sobre los puntos de datos,

00:15:45.790 --> 00:15:47.725
entonces puedes actuar en base a eso.

00:15:47.725 --> 00:15:50.590
Todas esas cosas
se convierten en características de

00:15:50.590 --> 00:15:54.070
cómo interactúa con sus datos.

00:15:54.070 --> 00:16:01.760
Así que aquí hay un poco más
puntos de comparación.

00:16:06.120 --> 00:16:09.070
Así que esto también se toma de ReactiveX.

00:16:09.070 --> 00:16:13.030
Como pueden ver aquí, tienen su
Iterable que es tu lapso,

00:16:13.030 --> 00:16:14.890
así que eso es como su IEnumerator y

00:16:14.890 --> 00:16:16.860
tienes razón, lo que
es su IObservable.

00:16:16.860 --> 00:16:19.150
Así que uno es obtener datos
de la memoria local,

00:16:19.150 --> 00:16:20.210
por lo que va a ser tal vez como un

00:16:20.210 --> 00:16:21.890
operación síncrona donde sólo

00:16:21.890 --> 00:16:23.870
tener sus datos se realizan en

00:16:23.870 --> 00:16:26.240
la parte superior y tienes razón
uno es de la red,

00:16:26.240 --> 00:16:29.580
podría ser una fuente de datos más lenta.

00:16:29.580 --> 00:16:32.915
Así que allí, se puede ver
se obtienen estas mismas ideas

00:16:32.915 --> 00:16:37.350
sobre sus transmisiones de eventos que
es sólo que es superpoderoso.

00:16:37.870 --> 00:16:42.940
Cosas bonitas. Muy bien.

00:16:42.940 --> 00:16:45.450
Vamos a desglosar cómo el

00:16:45.450 --> 00:16:48.610
bloques de construcción de
sus IObservables un poco aquí.

00:16:50.010 --> 00:16:54.250
Así que esta es la idea básica de
cómo se construye IObservable.

00:16:54.250 --> 00:16:57.205
Así que como ves en
ese primer paso allí,

00:16:57.205 --> 00:17:01.940
usted ve la suscripción familiar
y darse de baja,

00:17:03.840 --> 00:17:07.450
no es tan emocionante,
es sólo pasar a través de

00:17:07.450 --> 00:17:10.390
diferentes funciones para el observador,

00:17:10.390 --> 00:17:11.830
para que el observador sepa cómo tratar

00:17:11.830 --> 00:17:14.185
con suscripciones y cancelaciones de suscripción,

00:17:14.185 --> 00:17:18.250
para que pueda contener que
comportamiento dentro del IObservable.

00:17:18.250 --> 00:17:26.185
Así que aquí está la comparativa
versiones de los mismos,

00:17:26.185 --> 00:17:29.515
de lo que representan.

00:17:29.515 --> 00:17:34.690
Así que suscribirse es efectivamente
invocando a ese top guy,

00:17:34.690 --> 00:17:37.840
el superior en la parte superior en clic
y diciendo, "Bien,

00:17:37.840 --> 00:17:40.090
ahora me preocupo por mis eventos", y luego

00:17:40.090 --> 00:17:43.000
el inferior allí
ahora está desechando,

00:17:43.000 --> 00:17:45.715
que luego se da de baja.

00:17:45.715 --> 00:17:48.730
Aquí es donde comienza
para ser muy poderoso,

00:17:48.730 --> 00:17:54.535
porque tienes
toda esta representación

00:17:54.535 --> 00:17:58.210
se encapsula en un patrón familiar.

00:17:58.210 --> 00:18:01.810
Así que tienes IDisposable
que todos hemos usado,

00:18:01.810 --> 00:18:10.080
y tenemos estructuras de datos lógicas

00:18:10.080 --> 00:18:11.310
y formas en que podemos usar

00:18:11.310 --> 00:18:14.760
aquellos más efectivamente que
sólo decir dessuscribirse.

00:18:14.760 --> 00:18:18.700
Así que algunos realmente geniales
formas de hacerlo,

00:18:18.700 --> 00:18:20.680
usted puede manejar fácilmente
estos tiempos de vida.

00:18:20.680 --> 00:18:25.359
Así que recuerde antes de donde usted tiene
para asegurarse de darse de baja,

00:18:25.359 --> 00:18:28.600
así que como en Xamarin Forms, por ejemplo,

00:18:28.600 --> 00:18:32.590
si estás cambiando un elemento
o si algo nuevo viene

00:18:32.590 --> 00:18:34.210
en el que desea suscribirse a

00:18:34.210 --> 00:18:36.325
y no te importa
la vieja cosa ya,

00:18:36.325 --> 00:18:40.000
usted tiene que hacer esta cosa donde
te da de baja de la antigua,

00:18:40.000 --> 00:18:41.290
suscribirse a la nueva,

00:18:41.290 --> 00:18:44.920
entonces también su punto de eliminación tienen

00:18:44.920 --> 00:18:48.955
para asegurarse de que está dessuscribiéndose
de esos eventos también.

00:18:48.955 --> 00:18:50.650
Así que eso es lo que está bien, sin embargo,

00:18:50.650 --> 00:18:57.070
es que todo su evento
sistema de gestión de la observación

00:18:57.070 --> 00:19:00.055
se puede articular
a través de desechables.

00:19:00.055 --> 00:19:02.740
Actuamos a eso y mucho
de estas cosas aquí

00:19:02.740 --> 00:19:05.215
Desearía que sólo tiraran
en the.Net Marco,

00:19:05.215 --> 00:19:08.290
pero por ahora, en

00:19:08.290 --> 00:19:11.440
ReactiveX tienes estas cosas
como CompositeDisposable.

00:19:11.440 --> 00:19:13.450
Así que la idea que hay es
puede agregar

00:19:13.450 --> 00:19:17.035
todos sus desechables en
una sola estructura de datos,

00:19:17.035 --> 00:19:20.260
y luego esa estructura de datos ahora,

00:19:20.260 --> 00:19:22.225
puedes deshacer te una vez,

00:19:22.225 --> 00:19:26.125
una vez que la vida de
la clase contenedora se ha ido,

00:19:26.125 --> 00:19:28.540
y ahora todo tu evento
la administración es atendido.

00:19:28.540 --> 00:19:33.310
Para que pueda adjuntar su
PropertyLas suscripciones modificadas allí,

00:19:33.310 --> 00:19:37.570
sus suscripciones de TextChanged,
y luego te des haces de él.

00:19:37.570 --> 00:19:38.650
Así que es limpio porque te estás poniendo

00:19:38.650 --> 00:19:44.200
estos conceptos de objetoque que
puedes aplicar a tus eventos,

00:19:44.200 --> 00:19:48.740
así que es agradable, me gusta.

00:19:51.900 --> 00:19:55.030
Por ejemplo, como yo estaba
hablando de antes,

00:19:55.030 --> 00:19:57.430
donde tiene una instancia

00:19:57.430 --> 00:19:59.725
donde tienes un elemento viejo
a la que estás suscrito,

00:19:59.725 --> 00:20:01.000
Quiero decir que viene un nuevo elemento

00:20:01.000 --> 00:20:04.690
en por lo que no se preocupa por
el viejo ya.

00:20:04.690 --> 00:20:06.310
Así que tiene como estos conceptos geniales

00:20:06.310 --> 00:20:08.110
aquí con como una disposición en serie,

00:20:08.110 --> 00:20:09.910
donde todo lo que
asignar a esa voluntad

00:20:09.910 --> 00:20:12.250
automáticamente eliminar
de la cosa antes de ella.

00:20:12.250 --> 00:20:14.980
Así que en estas ideas aquí,

00:20:14.980 --> 00:20:16.900
No tienes que hacerlo

00:20:16.900 --> 00:20:19.690
darse de baja de lo que vino en
allí, que es realmente limpio.

00:20:19.690 --> 00:20:23.530
Pero usted sabe que esto es
la nueva belleza que te importa,

00:20:23.530 --> 00:20:25.390
y luego una vez que eso entra,

00:20:25.390 --> 00:20:28.735
usted acaba de deshacerse de
lo que había antes,

00:20:28.735 --> 00:20:30.370
por lo que le permite configurar

00:20:30.370 --> 00:20:36.470
estas expresiones realmente geniales
de lo que quieres hacer.

00:20:37.320 --> 00:20:41.770
Porque muchas de las cosas con
Reactivo, que es muy bonito,

00:20:41.770 --> 00:20:47.560
está teniendo toda su intención
en una sola ubicación.

00:20:47.560 --> 00:20:51.050
La gestión de eventos es
muy basado en la devolución de llamada,

00:20:52.080 --> 00:20:56.320
no te metes como malos estilos
como un infierno total de devolución de llamada,

00:20:56.320 --> 00:20:58.645
pero sigue siendo amable
de la misma cosa.

00:20:58.645 --> 00:21:01.330
Es la gestión de la devolución de llamada
y luego interactuar

00:21:01.330 --> 00:21:03.760
todas estas diferentes llamadas de llamada
escenarios cuando usted tiene

00:21:03.760 --> 00:21:06.665
lo mismo con la forma en que
gestionar la vida útil de la misma.

00:21:06.665 --> 00:21:13.470
Pero ¿alguien aquí ha hecho
¿Cosas de Xamarin Forms?

00:21:13.470 --> 00:21:17.050
Sólo estoy mapeando
modelos lógicos aquí.

00:21:17.050 --> 00:21:20.455
Así que usted tiene esta idea ahora donde

00:21:20.455 --> 00:21:25.690
la forma en que se puede

00:21:25.690 --> 00:21:27.250
gestionar todo el ciclo de vida de

00:21:27.250 --> 00:21:30.635
algo está bien
allí en esa parte media,

00:21:30.635 --> 00:21:33.840
y eso es todo lo que tienes que hacer.

00:21:33.840 --> 00:21:36.315
Una vez que eso está configurado allí,

00:21:36.315 --> 00:21:40.635
ahora en cualquier momento que venga y
tienes un cambio de elemento,

00:21:40.635 --> 00:21:42.650
y sólo te importa
sobre el nuevo elemento,

00:21:42.650 --> 00:21:47.230
asignación de nuevas causas desechables
el anterior para deshacerse,

00:21:47.230 --> 00:21:49.990
así que ahora todos sus eventos
están totalmente cableados,

00:21:49.990 --> 00:21:52.645
y ahora empiezas
cableando sus nuevos.

00:21:52.645 --> 00:21:53.860
Entonces en tu disposición,

00:21:53.860 --> 00:21:56.260
sólo tienes una sola
eliminación en serie que es

00:21:56.260 --> 00:22:01.750
su nivel de clase de recurso administrado
que usted está desechando de.

00:22:01.750 --> 00:22:06.880
Así que ahora no hay

00:22:06.880 --> 00:22:10.480
esta complejidad de la gestión como
en cuanto a su manejo de avances.

00:22:10.480 --> 00:22:13.300
Así que esto en realidad era
lo primero que me metió en

00:22:13.300 --> 00:22:17.630
La Programación Reactiva fue
la gestión desechable,

00:22:18.900 --> 00:22:22.150
Creo que fue como un año antes
Incluso había usado cualquier otra cosa.

00:22:22.150 --> 00:22:25.540
Sólo porque tenía un Silverlight
aplicación que estaba teniendo

00:22:25.540 --> 00:22:30.775
algunos problemas de suscripción y
entonces me encontré con estas cosas,

00:22:30.775 --> 00:22:32.815
así que esto es genial,

00:22:32.815 --> 00:22:34.870
los desechables me hacen súper feliz.

00:22:34.870 --> 00:22:37.390
Así que estos todavía están mapeando algunos de

00:22:37.390 --> 00:22:40.120
estas ideas que son
muy limpio, así que como aquí,

00:22:40.120 --> 00:22:42.700
recordar antes cuando
quería suscribirse sólo a

00:22:42.700 --> 00:22:45.445
que un evento y sólo
quería verlo una vez?

00:22:45.445 --> 00:22:48.640
Con Reactive, puede hacer

00:22:48.640 --> 00:22:52.045
todo ese concepto aquí
con esta expresión única.

00:22:52.045 --> 00:22:54.160
Así que todo esto lo dice,

00:22:54.160 --> 00:22:58.839
"Sólo quiero un valor de
esta propiedad cambiada,

00:22:58.839 --> 00:23:02.680
y luego en ese punto me
quiero que te des hagas de él."

00:23:02.680 --> 00:23:05.335
Así que eso es increíble justo ahí,

00:23:05.335 --> 00:23:07.555
Toma uno y luego cambia,

00:23:07.555 --> 00:23:10.180
que es un poco difícil de
entender, pero esos son

00:23:10.180 --> 00:23:13.270
razones suficientes
usarlo para siempre,

00:23:13.270 --> 00:23:15.340
es agradable, me gusta.

00:23:15.340 --> 00:23:22.210
Así que ese es el desglose de
cómo funcionan las operaciones.

00:23:22.210 --> 00:23:31.670
Así que tengo un par de demostraciones de
darse cuenta de esto en el código un poco más,

00:23:33.360 --> 00:23:39.970
pero quería dar algún concepto
prepárate para ti también,

00:23:39.970 --> 00:23:45.700
a algunos de los tipos de Reactivo
estructuras que estamos usando,

00:23:45.700 --> 00:23:47.980
sólo para que tenga un poco más de sentido.

00:23:47.980 --> 00:23:50.500
Así que una de las formas en que describe las cosas

00:23:50.500 --> 00:23:53.185
con Reactive es por
usando diagramas de mármol,

00:23:53.185 --> 00:23:55.075
por lo que hay estas ideas de ver

00:23:55.075 --> 00:24:01.405
su entrada y cuál es la salida.

00:24:01.405 --> 00:24:03.760
Así que los dos primeros aquí,

00:24:03.760 --> 00:24:10.285
este es el vernáculo para
información más reactiva,

00:24:10.285 --> 00:24:14.800
así que cada vez que veas
Operadores reactivos descritos,

00:24:14.800 --> 00:24:16.330
siempre se describen
en este formato.

00:24:16.330 --> 00:24:19.810
Así que la idea aquí es que
las dos cosas principales son flujos de datos,

00:24:19.810 --> 00:24:23.480
y luego el inferior es
lo que ve su suscriptor.

00:24:24.420 --> 00:24:27.519
La fusión serían dos suscriptores,

00:24:27.519 --> 00:24:29.980
así que como si estuvieras suscribiendo
para decir un evento TextChanged

00:24:29.980 --> 00:24:36.175
en una caja de nombre de usuario y un
contraseña, por ejemplo,

00:24:36.175 --> 00:24:38.620
en cualquier momento cualquiera de
los cambios esto es

00:24:38.620 --> 00:24:40.690
cómo se vería su salida.

00:24:40.690 --> 00:24:43.360
Así que estos son algunos de
los operadores que usé en la demo,

00:24:43.360 --> 00:24:44.620
así que sólo quería

00:24:44.620 --> 00:24:50.350
para asegurarse de que eran
entendido antes de seguir adelante.

00:24:50.350 --> 00:24:53.350
Así que Filter, esto es
básicamente como un donde,

00:24:53.350 --> 00:24:57.460
así que en el enlace a IEnumerable,

00:24:57.460 --> 00:25:00.280
es como un lugar.

00:25:00.280 --> 00:25:02.260
Tan efectivamente cualquier evento que venga

00:25:02.260 --> 00:25:05.810
a través, lo suficientemente simple para entender.

00:25:05.850 --> 00:25:09.100
Debounce, así que esto es
la otra característica realmente genial,

00:25:09.100 --> 00:25:11.395
así que esto está limitando sus entradas.

00:25:11.395 --> 00:25:13.570
Así que en este ejemplo lo que son

00:25:13.570 --> 00:25:16.210
demostrando aquí es
que sólo quieren

00:25:16.210 --> 00:25:17.710
el valor más reciente por venir

00:25:17.710 --> 00:25:21.025
a cabo después de un cierto
cantidad de tiempo.

00:25:21.025 --> 00:25:25.840
Así que puedes ver que hay un retraso
entre uno y cinco porque dos,

00:25:25.840 --> 00:25:27.745
tres, y cuatro son

00:25:27.745 --> 00:25:30.280
sucediendo tan juntos
que cinco está saliendo ahora.

00:25:30.280 --> 00:25:33.910
Así que esta es la porexcelencia
ejemplo de cosas reactivas,

00:25:33.910 --> 00:25:36.850
por lo que los casos en que los usuarios son

00:25:36.850 --> 00:25:39.400
haciendo como buscar con

00:25:39.400 --> 00:25:42.305
Google cuando están escribiendo
en su Autocompletar,

00:25:42.305 --> 00:25:45.220
pero no quieres que te guste la patada
fuera de una solicitud web cada vez,

00:25:45.220 --> 00:25:48.640
así que eso es efectivamente lo que
esto está demostrando,

00:25:48.640 --> 00:25:50.305
que tenemos un ejemplo de.

00:25:50.305 --> 00:25:56.640
Entonces TakeUntil es
el último operador que utilizo,

00:25:56.640 --> 00:25:58.110
así que TakeUntil es realmente limpio,

00:25:58.110 --> 00:26:01.170
porque eso es, por ejemplo,
parece una solicitud web.

00:26:01.170 --> 00:26:04.605
Así que digamos que una solicitud web
está empezando,

00:26:04.605 --> 00:26:07.210
y luego el usuario
comienza a escribir de nuevo,

00:26:07.210 --> 00:26:09.880
o dicen cancelar,

00:26:09.880 --> 00:26:11.560
como si no quisieran
ya no sucede,

00:26:11.560 --> 00:26:16.360
por lo que todos esos son otro
puntos de evento que se pueden promulgar,

00:26:16.360 --> 00:26:19.465
y en ese momento se corta
fuera de su transmisión más.

00:26:19.465 --> 00:26:22.375
Así que eso es como un realmente
forma sencilla de decir cortar,

00:26:22.375 --> 00:26:25.940
si no quieres una solicitud web
o algo así para terminar.

00:26:25.940 --> 00:26:32.400
Así que esa es la avería
de las cosas observables,

00:26:32.400 --> 00:26:35.470
así que permítanme cambiar,

00:26:36.080 --> 00:26:39.380
esperar un segundo.

00:26:39.380 --> 00:26:52.660
Genial, veamos.

00:26:53.540 --> 00:26:55.875
¿Es demasiado pequeño?

00:26:55.875 --> 00:26:57.610
>> Sí.

00:26:58.710 --> 00:27:01.330
>> Son cosas que
hacer cuando te das cuenta

00:27:01.330 --> 00:27:04.000
que nunca has hecho
estos en las demostraciones antes,

00:27:04.000 --> 00:27:07.525
En realidad nunca he aumentado
su tamaño de fuente en Obs Mac antes.

00:27:07.525 --> 00:27:16.300
Veamos. Estoy tratando de
hacer mis cosas de Windows aquí,

00:27:16.300 --> 00:27:20.540
ahí vamos, supongo que eso es todo.

00:27:22.580 --> 00:27:26.610
Muy bien, estaba probando
mis gestos en la almohadilla.

00:27:26.610 --> 00:27:27.630
Hice el golpe.

00:27:27.630 --> 00:27:28.650
Hice dos dedos,

00:27:28.650 --> 00:27:32.670
Yo hice esto. No sé.

00:27:32.670 --> 00:27:35.280
Supongo que no lo encontré.

00:27:35.280 --> 00:27:45.015
Así que ahí vamos. Está bien, sí.

00:27:45.015 --> 00:27:46.740
Así que al iniciar ventanas
donde acabas de golpear

00:27:46.740 --> 00:27:48.615
control y dividirlo.

00:27:48.615 --> 00:27:51.910
Muy bien para que todos
puede ver eso. ¿Muy bien?

00:27:52.070 --> 00:27:55.410
Así que permítanme ejecutar la demostración real

00:27:55.410 --> 00:27:59.895
rápido sólo para que tengamos contexto
de lo que estamos haciendo aquí.

00:27:59.895 --> 00:28:02.640
Así que esto es una especie de
una aplicación básica.

00:28:02.640 --> 00:28:08.355
Es sólo una idea de cierre de sesión.

00:28:08.355 --> 00:28:14.265
Sí, así que a continuación tengo un set
de los acontecimientos que están ocurriendo,

00:28:14.265 --> 00:28:21.690
por lo que esto es efectivamente
el flujo de datos de los observables.

00:28:21.690 --> 00:28:23.970
Así que todos los eventos que son
pasando con los observables.

00:28:23.970 --> 00:28:25.365
Así que aquí tenemos iniciar sesión.

00:28:25.365 --> 00:28:27.240
Así que esto es usuario y contraseña

00:28:27.240 --> 00:28:28.665
que debería haber puesto
un registro de marcadores de posición.

00:28:28.665 --> 00:28:34.095
Pero así que la idea aquí que
puede ver si golpeo una carta.

00:28:34.095 --> 00:28:36.509
allí. Así que golpea una carta

00:28:36.509 --> 00:28:39.090
y en ese momento es
validar la entrada.

00:28:39.090 --> 00:28:41.175
Ahora puedes ver que
hay una especie de retraso.

00:28:41.175 --> 00:28:43.935
¿Correcto? Así que si golpeo
"O" hay un retraso.

00:28:43.935 --> 00:28:46.170
Así que la idea detrás
es decir, que estás

00:28:46.170 --> 00:28:49.455
no- eso es que debouncing
de lo que estás hablando.

00:28:49.455 --> 00:28:54.945
Así que si escribo el "Nombre de usuario"
y la "Contraseña".

00:28:54.945 --> 00:28:59.310
allí. Se puede ver que una vez
que la validación sucede.

00:28:59.310 --> 00:29:01.710
Así que eso es sólo que vamos a romper
por estas estructuras una vez que

00:29:01.710 --> 00:29:04.275
entrar allí, pero eso es
la idea detrás de ella.

00:29:04.275 --> 00:29:08.910
así que. Sí. Tan emocionante.

00:29:08.910 --> 00:29:11.955
Ahora tenemos una simulación para el inicio de sesión.

00:29:11.955 --> 00:29:14.250
Así que la idea aquí hago clic en "Iniciar sesión".

00:29:14.250 --> 00:29:18.840
Inicia una solicitud web y luego
en ese momento se puede cerrar la sesión.

00:29:18.840 --> 00:29:21.870
Así que y hay una especie de

00:29:21.870 --> 00:29:26.415
adicional vamos a ver cuántas veces
toma antes de que esto se desencadene.

00:29:26.415 --> 00:29:30.090
Así que tengo un aleatorizador
allí al azar

00:29:30.090 --> 00:29:35.415
generar errores. Ahí está.

00:29:35.415 --> 00:29:38.400
Fresco. Así que se puede ver aquí lo que

00:29:38.400 --> 00:29:41.775
sucede que yo
haciendo clic en el "Iniciar sesión".

00:29:41.775 --> 00:29:44.535
Generó una excepción.

00:29:44.535 --> 00:29:47.895
Así como la excepción de solicitud web.

00:29:47.895 --> 00:29:51.630
Entonces dijo que está bien vamos a
pruebe la solicitud web de nuevo.

00:29:51.630 --> 00:29:59.640
Entonces en ese momento
entonces me registró, ¿verdad?

00:29:59.640 --> 00:30:02.655
Entonces el otro aspecto
de esto que soy yo.

00:30:02.655 --> 00:30:05.070
Como digamos que el usuario
quiere cancelarlo.

00:30:05.070 --> 00:30:09.100
Así que si hacen clic en "Iniciar sesión"
pueden hacer clic en "Cancelar".

00:30:09.350 --> 00:30:13.470
Allí se puede ver ahora no es
procesamiento de los datos.

00:30:13.470 --> 00:30:16.035
¿Correcto? Así que porque

00:30:16.035 --> 00:30:18.885
hay un tipo de operación
de cancelar eso.

00:30:18.885 --> 00:30:23.805
Así que esto es para la demostración.

00:30:23.805 --> 00:30:25.815
Sí, así que esta es la idea detrás.

00:30:25.815 --> 00:30:27.900
Este es el código.

00:30:27.900 --> 00:30:32.160
Sí, así que la idea

00:30:32.160 --> 00:30:34.965
detrás de esto a tipo de
derribar las estructuras.

00:30:34.965 --> 00:30:37.935
Ya que todos hemos visto mucho
de estas cosas es que

00:30:37.935 --> 00:30:41.340
esta es la composibilidad
aspecto de los observables.

00:30:41.340 --> 00:30:43.890
El aspecto de la comonabilidad
es que usted tiene

00:30:43.890 --> 00:30:46.920
esta representación de sus eventos como

00:30:46.920 --> 00:30:50.730
estos flujos de datos individuales
que entonces se puede empezar a

00:30:50.730 --> 00:30:55.845
intermezcla para articular
el comportamiento de su aplicación.

00:30:55.845 --> 00:31:01.050
Así que si tenemos la aplicación lo que son
todas las transmisiones de eventos aquí.

00:31:01.050 --> 00:31:03.360
Las secuencias de eventos son
tenemos la entrada en

00:31:03.360 --> 00:31:07.065
la parte superior tenemos la entrada
en los segundos campos.

00:31:07.065 --> 00:31:10.320
Como los tipos de usuario que tenemos
el clic del botón Iniciar sesión.

00:31:10.320 --> 00:31:12.975
Tenemos el clic en el botón Cancelar
y tenemos como la Solicitud Web.

00:31:12.975 --> 00:31:17.205
Así que efectivamente hemos
cinco eventos diferentes.

00:31:17.205 --> 00:31:20.550
Streams que necesitamos describir.

00:31:20.550 --> 00:31:28.545
Así que podemos romper estos
en sus partes reactivas.

00:31:28.545 --> 00:31:32.145
Así que todos estos son bastante poco emocionantes.

00:31:32.145 --> 00:31:37.050
Esto es lo mismo que tú
visto antes de lo cual es básicamente

00:31:37.050 --> 00:31:39.180
sólo diciendo Hey quiero crear esto

00:31:39.180 --> 00:31:42.630
observable que está escuchando
al evento en el que se ha clic.

00:31:42.630 --> 00:31:46.095
Así que este es el aspecto central
de esto que es emocionante.

00:31:46.095 --> 00:31:51.825
Así que creamos un observable para
cada uno de estos diferentes elementos.

00:31:51.825 --> 00:31:54.030
Tenemos nuestro inicio de sesión.

00:31:54.030 --> 00:31:55.470
Así que es cuando hacen clic.

00:31:55.470 --> 00:31:56.805
Tenemos nuestro cierre de sesión.

00:31:56.805 --> 00:31:58.440
Ahí es cuando cierran la sesión.

00:31:58.440 --> 00:32:01.785
Tenemos nuestra cancelación. Es decir
cuando hacen clic en "Cancelar".

00:32:01.785 --> 00:32:06.750
Tenemos el cambio de texto
aquí que es cuando están

00:32:06.750 --> 00:32:09.000
escribiendo el nombre de usuario y tenemos

00:32:09.000 --> 00:32:12.090
la contraseña aquí cuando están
escribir la contraseña.

00:32:12.090 --> 00:32:15.300
Entonces, hacemos
una llamada falsa de solicitud web.

00:32:15.300 --> 00:32:17.670
Así que esto está demostrando.

00:32:17.670 --> 00:32:20.565
Es esencialmente sólo
esperando dos segundos.

00:32:20.565 --> 00:32:22.440
Luego, una vez que termina, genera

00:32:22.440 --> 00:32:26.265
un error si algunos aleatorios
número es igual a dos.

00:32:26.265 --> 00:32:35.010
Sí. Así que esa es nuestra aplicación.

00:32:35.010 --> 00:32:38.250
Eso es en observable
representación de

00:32:38.250 --> 00:32:41.985
todos los eventos que pueden ocurrir
en la aplicación, ¿verdad?

00:32:41.985 --> 00:32:43.860
Así que ahora aquí es donde

00:32:43.860 --> 00:32:47.680
el aspecto de la comonabilidad viene
en juego que es realmente genial.

00:32:48.500 --> 00:32:51.150
Ahora, todos estos
diferentes observables

00:32:51.150 --> 00:32:53.220
tomar una vida propia.

00:32:53.220 --> 00:33:00.060
Así que la totalidad de
la lógica que se ve

00:33:00.060 --> 00:33:06.990
se encarna con una
simple cantidad de código, ¿verdad?

00:33:06.990 --> 00:33:12.780
Así que aquí está nuestro código de validación.

00:33:12.780 --> 00:33:14.940
Así que ahora lo que hacemos es
estamos construyendo

00:33:14.940 --> 00:33:18.810
observables adicionales en
estos otros observables.

00:33:18.810 --> 00:33:21.990
¿Correcto? Así que eso es lo que es
el aspecto de composición de la misma.

00:33:21.990 --> 00:33:23.640
Así que el primero es que

00:33:23.640 --> 00:33:26.520
decir bien queremos un
observable autenticado.

00:33:26.520 --> 00:33:29.580
El observable autenticado
es el usuario haciendo clic

00:33:29.580 --> 00:33:33.060
"Iniciar sesión" y hacer clic
"Solicitud Web".

00:33:33.060 --> 00:33:39.090
Así que ahora hemos compuesto estos dos
ideas de eventos observables.

00:33:39.090 --> 00:33:42.870
Ahora hemos fusionado estos datos
flujo con un cierre de sesión.

00:33:42.870 --> 00:33:47.250
Por lo tanto, si un usuario hace clic en "Cerrar sesión"
entonces eso es decir "Oye,

00:33:47.250 --> 00:33:48.735
Quiero que cierres la sesión."

00:33:48.735 --> 00:33:54.480
Así que tenemos todo el
estado de autenticación de

00:33:54.480 --> 00:34:00.525
la solicitud representada por
un nuevo observable autenticado.

00:34:00.525 --> 00:34:02.295
Observable autenticado.

00:34:02.295 --> 00:34:05.295
Así que ese es el único observable
nos importa en este punto.

00:34:05.295 --> 00:34:07.530
Así es como ahora podemos usar eso

00:34:07.530 --> 00:34:09.540
observable en cualquier otro lugar donde

00:34:09.540 --> 00:34:14.940
queremos preguntar acerca de lo que es
el usuario autenticado.

00:34:14.940 --> 00:34:18.190
Sabes cuál es la necesidad.

00:34:19.910 --> 00:34:22.620
Entonces aquí tenemos nuestra validación.

00:34:22.620 --> 00:34:24.720
Nuestra validación es una composición de

00:34:24.720 --> 00:34:29.410
nuestro nombre de usuario y nuestra contraseña
allí que es agradable.

00:34:29.570 --> 00:34:33.645
Así que esencialmente entra.

00:34:33.645 --> 00:34:35.894
Dice "Oye,

00:34:35.894 --> 00:34:38.909
estos son los puntos de datos
que representan la validez."

00:34:38.909 --> 00:34:43.080
Transforma esos eventos en un

00:34:43.080 --> 00:34:47.910
verdadero o un valor falso que
ahora puede usar para decir, "Bien.

00:34:47.910 --> 00:34:53.860
¿Cuál es el estado de los eventos
que han estado entrando? "

00:34:55.190 --> 00:34:58.515
Entonces esto vamos a ahora

00:34:58.515 --> 00:35:01.455
poner juntos- Ahora podemos poner
todas estas cosas juntas.

00:35:01.455 --> 00:35:03.120
Aquí es donde tipo de
como el funcional

00:35:03.120 --> 00:35:05.295
aspecto de programación reactiva
entra en juego.

00:35:05.295 --> 00:35:08.880
Ahora podemos poner todos estos diferentes
observa juntos en

00:35:08.880 --> 00:35:10.485
un lugar pequeño y agradable

00:35:10.485 --> 00:35:15.255
aquí que describe todo
eso va a estar sucediendo.

00:35:15.255 --> 00:35:17.760
Así que esta es la parte de
que es realmente limpio.

00:35:17.760 --> 00:35:22.995
Porque con esto
aplicación que puede obtener

00:35:22.995 --> 00:35:27.120
un alcance de perspectiva sobre todos los

00:35:27.120 --> 00:35:31.710
la lógica sólo por tener razón
aquí en este punto de código.

00:35:31.710 --> 00:35:36.060
No hay necesidad de
saltar alrededor o cualquier cosa.

00:35:36.060 --> 00:35:40.170
Es un lugar inmutable basado en

00:35:40.170 --> 00:35:46.485
datos inmutables para modificar
cómo funcionan estos puntos de datos.

00:35:46.485 --> 00:35:50.190
Así que es agradable porque
es una manera fácil y agradable.

00:35:50.190 --> 00:35:53.490
Así como los datos que vienen
en este valor de resultado aquí

00:35:53.490 --> 00:35:57.450
es una estructura inmutable.

00:35:57.450 --> 00:36:00.435
A continuación, en función de estos datos que
conocer autenticado observable.

00:36:00.435 --> 00:36:02.760
Así que lo que esto está haciendo
aquí está diciendo lo que es

00:36:02.760 --> 00:36:06.315
su estado de autenticación es si
estás autenticado o no.

00:36:06.315 --> 00:36:10.845
Valid está diciendo si el
credenciales que introdujeron como válidas.

00:36:10.845 --> 00:36:12.360
Entonces basado en eso,

00:36:12.360 --> 00:36:17.320
configurar la visibilidad
de su solicitud.

00:36:20.170 --> 00:36:22.890
Sí, para que puedas configurar
como la visibilidad de

00:36:22.890 --> 00:36:26.200
su solicitud. Así que está limpio.

00:36:28.340 --> 00:36:31.905
Así que vamos a ver.

00:36:31.905 --> 00:36:34.350
Tengo una demo más muy rápido,

00:36:34.350 --> 00:36:36.820
sólo uno pequeño.

00:36:39.350 --> 00:36:43.725
Oops, un poco demasiado grande
allí. Aquí vamos.

00:36:43.725 --> 00:36:45.345
Todo el mundo ve eso, ¿de acuerdo?

00:36:45.345 --> 00:36:50.400
Sí. Muy bien. Tengo estos
como repositorios gitHub.

00:36:50.400 --> 00:36:53.520
Esto está usando un poco
de las cosas reactivas de la interfaz de usuario,

00:36:53.520 --> 00:36:55.695
pero permítanme mostrar.

00:36:55.695 --> 00:37:00.730
Esto tiene algunas muestras diferentes
que puedes echar un vistazo.

00:37:02.360 --> 00:37:10.240
Con suerte, funciona. ¿Es
ya está corriendo? Ahí va.

00:37:10.940 --> 00:37:14.980
Así que muchos de estos son
cosas simples que ves.

00:37:15.050 --> 00:37:17.775
Echemos un vistazo a la
posición demo ya que estamos

00:37:17.775 --> 00:37:19.905
se está agotando el tiempo aquí.

00:37:19.905 --> 00:37:21.900
Así que la idea de la demo de la posición

00:37:21.900 --> 00:37:24.810
es que es que estás rastreando
el puntero del ratón.

00:37:24.810 --> 00:37:30.780
Este tiene otro ejemplo popular
para conceptos reactivos.

00:37:30.780 --> 00:37:32.055
Así que empujas hacia abajo.

00:37:32.055 --> 00:37:33.660
Está detectando que presionas.

00:37:33.660 --> 00:37:34.740
Si mueves el ratón,

00:37:34.740 --> 00:37:36.000
ahora está detectando que te mudaste,

00:37:36.000 --> 00:37:37.380
y luego se suelta, y da

00:37:37.380 --> 00:37:40.335
una agregación de todos sus datos.

00:37:40.335 --> 00:37:49.380
Se ha roto un poco

00:37:49.380 --> 00:37:51.720
porque necesito tener
las descripciones,

00:37:51.720 --> 00:37:56.080
pero es muy limpio porque
todo lo que tienes que hacer realmente,

00:37:56.120 --> 00:37:58.905
usted tiene su puntero presionado evento.

00:37:58.905 --> 00:38:01.200
Así que tienes el puntero
prensa que dice,

00:38:01.200 --> 00:38:03.840
"Oye, he presionado el ratón hacia abajo."

00:38:03.840 --> 00:38:06.840
Ahora, una vez que esto ha
sucedió, dices, "Bien,

00:38:06.840 --> 00:38:10.395
Quiero suscribirme a
el puntero que se mueve alrededor.

00:38:10.395 --> 00:38:14.170
Así que este es ahora el puntero
ser movido.

00:38:14.240 --> 00:38:16.800
Como se está moviendo ahora,

00:38:16.800 --> 00:38:20.085
usted está tirando de todos estos datos
juntos aquí,

00:38:20.085 --> 00:38:23.145
y luego el operador de dos listas, aquí,

00:38:23.145 --> 00:38:24.960
ahora es capaz de
agregar todos esos datos

00:38:24.960 --> 00:38:27.405
juntos en un único conjunto de datos.

00:38:27.405 --> 00:38:29.760
Entonces aquí, la toma hasta que fue

00:38:29.760 --> 00:38:32.220
la única operación que
estábamos mostrando aquí.

00:38:32.220 --> 00:38:34.170
Dice, "Oye, está bien,
Sólo quiero que

00:38:34.170 --> 00:38:36.270
tomar estos datos y decir
los punteros liberados."

00:38:36.270 --> 00:38:38.309
Así que obtienes esto realmente
interacción fresca

00:38:38.309 --> 00:38:40.020
de todos estos eventos para decir,

00:38:40.020 --> 00:38:41.940
porque todo lo que realmente querías
decir es que quiero moverme

00:38:41.940 --> 00:38:44.130
el ratón alrededor y cuando
soltaron el ratón,

00:38:44.130 --> 00:38:45.810
Quiero todos los datos que había allí.

00:38:45.810 --> 00:38:47.160
Así que usted puede obtener todo esto

00:38:47.160 --> 00:38:50.505
representado en este bonito
poca suscripción aquí.

00:38:50.505 --> 00:38:55.120
Así que este es uno de los
esos ejemplos principales.

00:38:57.130 --> 00:39:03.360
Sí, así que eso es un primer rápido
en los conceptos reactivos.

00:39:04.690 --> 00:39:08.940
Hay un montón de
buenos marcos por ahí.

00:39:11.210 --> 00:39:16.740
Vaya, no es útil. Aquí vamos.

00:39:16.740 --> 00:39:23.280
Sí. Así que esa es la idea detrás
la mayoría de los observables.

00:39:23.280 --> 00:39:25.530
Michael va a hablar
un poco más sobre el uso

00:39:25.530 --> 00:39:28.545
estos marcos con MVVM.

00:39:28.545 --> 00:39:32.880
Hay un montón de muy poderoso
herramientas como los datos dinámicos.

00:39:32.880 --> 00:39:35.100
Seleccione Datos dinámicos, es

00:39:35.100 --> 00:39:37.590
una plataforma realmente genial

00:39:37.590 --> 00:39:41.985
para superpoder en sus listas
con observables.

00:39:41.985 --> 00:39:43.890
Así que la idea es que usted puede

00:39:43.890 --> 00:39:46.995
esencialmente hacer
todo y observable.

00:39:46.995 --> 00:39:49.660
Puedes firmarlo,
No lo sabía.

00:39:51.470 --> 00:39:53.610
Así que supongo que muy rápido,

00:39:53.610 --> 00:39:55.960
¿Alguien tiene preguntas?

00:39:57.410 --> 00:40:00.720
Sí, Sam. Bueno, sí.

00:40:00.720 --> 00:40:04.095
Iremos allí. Vamos a
hacer preguntas unos 35 minutos.

00:40:04.095 --> 00:40:05.520
>> Así que hablar de

00:40:05.520 --> 00:40:10.380
la divulgación de la
[inaudible] y todas esas cosas.

00:40:10.380 --> 00:40:14.220
Hable acerca de por qué los observadores
son mejores [inaudibles].

00:40:14.220 --> 00:40:20.460
>> Sí, así que

00:40:20.460 --> 00:40:24.045
supongo que diría que porque
la administración- Así que la pregunta era,

00:40:24.045 --> 00:40:25.680
con la pérdida de memoria,

00:40:25.680 --> 00:40:28.290
¿por qué es el hecho de que regresa

00:40:28.290 --> 00:40:31.245
un desechable mejor primero
decir gestión de la memoria?

00:40:31.245 --> 00:40:33.090
La idea es que, sí,

00:40:33.090 --> 00:40:37.230
es el hecho de que
es la vida de

00:40:37.230 --> 00:40:43.665
lo observable es un aspecto
de la suscripción.

00:40:43.665 --> 00:40:46.920
Así que cuando te suscribes
a ella, vuelves,

00:40:46.920 --> 00:40:49.395
porque cada vez que se
un desechable de algo,

00:40:49.395 --> 00:40:51.270
usted sabe que usted tiene
para deshacerse de él.

00:40:51.270 --> 00:40:54.630
Como si ese es el paradigma que usamos.

00:40:54.630 --> 00:40:57.060
Así que esa es la idea al respecto.

00:40:57.060 --> 00:41:01.365
Es eso con la ventilación
especialmente para los nuevos programadores,

00:41:01.365 --> 00:41:03.660
siempre van a
hacer eso como error

00:41:03.660 --> 00:41:07.700
donde están como algo

00:41:07.700 --> 00:41:08.810
va a sobrevivir a otra cosa

00:41:08.810 --> 00:41:10.250
porque tienes que entender eso.

00:41:10.250 --> 00:41:15.360
Pero un desechable es
un concepto muy básico.

00:41:15.360 --> 00:41:19.155
Así que tener eso como parte
de la suscripción

00:41:19.155 --> 00:41:22.860
hace que su gestión de la memoria
escenarios más fáciles.

00:41:22.860 --> 00:41:25.440
Sí.

00:41:25.440 --> 00:41:26.940
¿Alguna otra pregunta?

00:41:26.940 --> 00:41:28.727
Sí.

00:41:28.727 --> 00:41:35.250
>> [inaudible].

00:41:35.250 --> 00:41:39.060
>> Sí. Así que la pregunta era,

00:41:39.060 --> 00:41:41.985
puede utilizar Programación Reactiva

00:41:41.985 --> 00:41:45.060
con cosas como tareas o
programación asíncrona?

00:41:45.060 --> 00:41:50.865
Sí. Así que una tarea es efectivamente
una notificación de un punto.

00:41:50.865 --> 00:41:53.355
Así que cuando tienes una tarea,

00:41:53.355 --> 00:41:57.210
hay tres puntos de datos para
una tarea que es exactamente como

00:41:57.210 --> 00:42:02.175
nuestro iterador cuando estábamos indicando.

00:42:02.175 --> 00:42:05.040
Así que cuando escribes una tarea- Bien,

00:42:05.040 --> 00:42:06.615
No sé dónde está.
subiendo. Muy bien.

00:42:06.615 --> 00:42:08.190
Así que cuando tienes una tarea,

00:42:08.190 --> 00:42:14.145
usted crea la tarea por lo que es
lo tienes al principio,

00:42:14.145 --> 00:42:19.724
entonces se inicia la tarea
así que ahora se está ejecutando,

00:42:19.724 --> 00:42:23.355
y luego la tarea produce un valor,

00:42:23.355 --> 00:42:26.445
esos son tus resultados de puntos
que ninguno de nosotros está escribiendo,

00:42:26.445 --> 00:42:29.970
y luego se completa en
la finalización de eso.

00:42:29.970 --> 00:42:31.440
Así que en ese punto,

00:42:31.440 --> 00:42:35.190
tiene un punto de datos observable.

00:42:35.190 --> 00:42:40.680
Así que lo desechable crea cosas

00:42:40.680 --> 00:42:42.900
que funcionan exactamente en contra de la tarea por lo que

00:42:42.900 --> 00:42:45.180
que se puede crear un
observable en contra de la tarea.

00:42:45.180 --> 00:42:49.125
Entonces, lo que sucederá es cuando
te suscribes a ese observable,

00:42:49.125 --> 00:42:54.494
es que efectivamente va a iniciar la tarea
y luego una vez que eso sucede,

00:42:54.494 --> 00:42:56.190
que reactiva los resultados.

00:42:56.190 --> 00:42:59.655
Así que eso produce un valor
y luego se completa.

00:42:59.655 --> 00:43:01.410
Entonces eso es otra cosa
eso es realmente súper

00:43:01.410 --> 00:43:03.600
útil porque si esa tarea falla,

00:43:03.600 --> 00:43:05.040
usted consigue sus cosas con

00:43:05.040 --> 00:43:07.485
observables donde
puede detectar la excepción.

00:43:07.485 --> 00:43:13.500
Así, por ejemplo, los escenarios
como async void, por ejemplo.

00:43:13.500 --> 00:43:16.575
El vacío asincrónico no es un problema
con observables.

00:43:16.575 --> 00:43:18.495
Nunca tienes que preocuparte por

00:43:18.495 --> 00:43:21.970
asincrónico vacío Si eres
haciendo observables.

00:43:22.040 --> 00:43:26.520
Así que, por ejemplo, ya sabes cómo
tal vez quiera iniciar una tarea asincrónica

00:43:26.520 --> 00:43:28.050
de un constructor o cosas como

00:43:28.050 --> 00:43:30.060
que o estas cuestiones de
aquellos con observables,

00:43:30.060 --> 00:43:31.200
eso ni siquiera es un escenario,

00:43:31.200 --> 00:43:34.320
porque usted acaba de envolver la tarea en un

00:43:34.320 --> 00:43:36.180
observable y luego tienes

00:43:36.180 --> 00:43:39.225
el comportamiento de excepción como parte
de lo observable con la tarea.

00:43:39.225 --> 00:43:40.710
Así que sí, funcionan.

00:43:40.710 --> 00:43:42.060
Son geniales para las tareas.

00:43:42.060 --> 00:43:43.770
Así que ahí me olvido de quién habla.

00:43:43.770 --> 00:43:46.260
Jeffrey o algo así como
que hace una charla al respecto;

00:43:46.260 --> 00:43:48.015
hablando de cómo son las tareas

00:43:48.015 --> 00:43:50.010
súper malo y usted debe
sólo usa observables.

00:43:50.010 --> 00:43:51.360
Pero sí, una vez que empieces a usar

00:43:51.360 --> 00:43:53.685
observables especialmente
en el código de interfaz de usuario,

00:43:53.685 --> 00:43:55.260
usted efectivamente acaba de poner

00:43:55.260 --> 00:43:57.420
una fachada frente a todos los
de sus tareas porque

00:43:57.420 --> 00:44:02.080
se vuelve mucho más simple
gestionar a través de observables.

00:44:02.450 --> 00:44:04.905
¿Alguna otra pregunta?

00:44:04.905 --> 00:44:07.840
Voy por el shhh.

00:44:09.380 --> 00:44:12.870
¿Puedo tomar uno más
¿Pregunta? ¿No? Está bien, no.

00:44:12.870 --> 00:44:15.075
Responderé a su
pregunta justo después.

00:44:15.075 --> 00:44:17.340
Fresco. Así que sí, soy Shane.

00:44:17.340 --> 00:44:20.500
Esos son mis observables.