Rx la joya oculta de Net

4,080 views 53 slides Mar 06, 2016
Slide 1
Slide 1 of 53
Slide 1
1
Slide 2
2
Slide 3
3
Slide 4
4
Slide 5
5
Slide 6
6
Slide 7
7
Slide 8
8
Slide 9
9
Slide 10
10
Slide 11
11
Slide 12
12
Slide 13
13
Slide 14
14
Slide 15
15
Slide 16
16
Slide 17
17
Slide 18
18
Slide 19
19
Slide 20
20
Slide 21
21
Slide 22
22
Slide 23
23
Slide 24
24
Slide 25
25
Slide 26
26
Slide 27
27
Slide 28
28
Slide 29
29
Slide 30
30
Slide 31
31
Slide 32
32
Slide 33
33
Slide 34
34
Slide 35
35
Slide 36
36
Slide 37
37
Slide 38
38
Slide 39
39
Slide 40
40
Slide 41
41
Slide 42
42
Slide 43
43
Slide 44
44
Slide 45
45
Slide 46
46
Slide 47
47
Slide 48
48
Slide 49
49
Slide 50
50
Slide 51
51
Slide 52
52
Slide 53
53

About This Presentation

Presentación sobre Reactive Extensions (Rx) en la conferencia DotNetSpain 2016 en Madrid.


Slide Content

Edin Kapić SharePoint Practice Lead @ Sogeti Spain e din @edinkapic.com Rx , la joya oculta de NET

¿Rx? Introducción Rx Observables Sujetos Tratamiento de secuencias ¡Rx! Reimaginando nuestro código Rx en en mundo real Más allá de Rx Agenda

Senior Architect & SharePoint Practice Lead Edin Kapi ć @ ekapic www.edinkapic.com Presidente Autor

¿ Rx ?

Rx (Reactive eXtensions ) es una librería .NET que permite hacer programación reactiva ¿Qué es Rx ? Sí, esto es lo que parece: una anguila eléctrica ( Electrophorus electricus )

Un modelo de programación orientado a flujos de datos y la propagación de los cambios https:// en.wikipedia.org/wiki/Reactive_programming ¿Qué es programación reactiva? Esto es un marble diagram (diagrama de canicas)

Flujos de datos y Rx API unificada de consumo de datos asíncronos

Rx = Observables + LINQ + Schedulers Rx = LINQ-to- Events IEnumerable = Pull , IObservable = Push Analogías útiles

La arquitectura de Rx

NuGet Rx-Main NET 4+ UWP Windows Phone NuGet RxJS -Main JavaScript NPM Rx Node.js ¿Cómo obtener Rx ? System.Reactive

Rx en otras plataformas

Rx

static void Main ( string [] args ) { IObservable < char > obs = " Hello , world !" . ToObservable ();   obs.Subscribe (x => Console .WriteLine (x ));   Console .ReadLine (); } Hello , world con Rx

Secuencia (flujo, stream ) asíncrona de datos Observable namespace System { public interface IObservable < out T> { IDisposable Subscribe ( IObserver <T> observer ); } }

El consumidor de una secuencia observable Observer namespace System { public interface IObserver < in T > { void OnCompleted (); void OnError ( Exception error); void OnNext (T value ); } }

Un momento, ¿esto no es algo parecido a… … enumerables ? …eventos?

Observable versus Enumerable IObservable Subscribe() IObserver OnNext () OnCompleted () OnError () IEnumerable GetEnumerator () IEnumerator Current MoveNext () Reset () 1…2….3…. Observer 1…2….3…. Enumerator OnNext () MoveNext () Push Pull

Observable versus Eventos Observable Objetos “de primera” Todo son métodos normales Se pueden hacer consultas históricas Ciclo de vida sencillo basado en IDisposable Evento Difícil de componer varios eventos += -= no es muy amigable No hay histórico de eventos Difícil de controlar el ciclo de vida IObservable = Eventos+++ 1 2 Handler Source Observer Observer Observer

Vale, seguimos con Rx …

Subject es IObservable y IObserver a la vez Útil para hacer de proxy entre los “clientes” y el “origen” de datos Subject <T> var subject = new Subject < string >(); subject.Subscribe ( value => Console .WriteLine ( value )); subject.OnNext ( "a" ); subject.OnNext ( "b" ); subject.OnNext ( "c" );

Tipos de Subjects ReplaySubject <T> BehaviorSubject <T> AsyncSubject <T> Reproduce todos los valores de la secuencia para todos los suscritores Reproduce el último valor de la secuencia Publica el último resultado de la secuencia al acabar Subject.Create ()

Ciclo de vida de una suscripción Suscripción var sub = IObservable.Subscribe (…); Fin de suscripción sub.Dispose (); Observable Observer OnNext (1) Subscribe( observer ) Subscription : IDisposable OnNext (2) 1 2

Secuencias finitas y los errores Observable Observer OnCompleted () Subscribe( observer ) Subscription : IDisposable OnError ( exception ) 1 2 

Creación de secuencias Manualmente Observable.Return Observable.Empty Observable.Never Observable.Range Observable.Create Observable.Generate Observable.Interval Observable.Timer A partir de otras cosas Observable.Start Observable.FromEventPattern Observable.FromAsyncPattern Task.ToObservable IEnumerable.ToObservable

Muy bonito, pero no le veo la utilidad

Ejemplo : Búsqueda en redes sociales SearchObservable Subscribe() OnNext (x) TwitterSrch FacebookSrch InstagramSrch Observable.Merge () GetResultAsync () GetResultAsync () GetResultAsync () Task <T>. ToObservable () Internet

¿ Qué podemos hacer con las secuencias ? 1 2 2 1 2 1 2 Filtrar Combinar 1 2 3 Mapear 1 2 B Reducir A Where (x== 2) Merge () Select(f(x)) Sum ()

Where OfType GroupBy Buffer Window Distinct DistinctUntilChanged Skip Take SkipUntil TakeUntil Operadores LINQ Filtrar Agrupar Valores únicos Partición http://freecontent.manning.com/animated-gifs/? s=reactive-extensions

Proyección Select SelectMany 1 2 B A 1 2 A B A Select( x.ToLetter ) Select( x.FromAToLetter )

Count , Min, Max, Sum , Average Devuelven un valor escalar First , Last , Single Devuelven un elemento de la secuencia Aggregate , Scan Función de reducción Reducción 1 2 3 Sum ()

Un momento, no he visto nada de “secuencias en el tiempo” todavía…

Combinar secuencias Concat Switch 1 2 2 1 3 4 3 4 Merge 1 2 3 1 3 4 2 4 1 2 3 3 4 4

Schedulers public interface IScheduler { DateTimeOffset Now { get ; } IDisposable Schedule< TState >( TState state , Func < IScheduler , TState , IDisposable > action ); IDisposable Schedule< TState >( TState state , DateTimeOffset dueTime , Func < IScheduler , TState , IDisposable > action ); IDisposable Schedule< TState >( TState state , TimeSpan dueTime , Func < IScheduler , TState , IDisposable > action ); }

new Thread (() => { /* do work */ }). Start () ThreadPool.QueueUserWorkItem (_ => { /* do work */ }, null ) Task.Factory.StartNew (() => { /* do work */ }) syncCtx.Post (_ => { /* do work */ }, null ) Dispatcher.BeginInvoke (() => { /* do work */ }) Abstracción de concurrencia s cheduler.Schedule (() => { /* do work */ })

La mayoría de las operaciones de Rx usan schedulers Rx y concurrencia

Scheduler como parámetro

Tipos de schedulers ImmediateScheduler CurrentThreadScheduler NewThreadScheduler EventLoopScheduler HistoricalScheduler ControlScheduler DispatcherScheduler SynchronizationContextScheduler TaskPoolScheduler ThreadPoolScheduler Genéricos Implementados por la plataforma

HistoricalScheduler http:// blogs.msdn.com/b/rxteam/archive/2012/06/14/testing-rx-queries-using-virtual-time-scheduling.aspx

SubscribeOn Donde se ejecuta el Observable ObserveOn Donde se ejecuta el Observer Cambiando el lugar de la ejecución

¡ Rx !

Código que gestiona llamadas asíncronas o eventos Código que manipula secuencias asíncronas de datos ¿ Dónde aplicar Rx ? https:// github.com/AdaptiveConsulting/ReactiveTrader

Ejemplo : Sugerencias de búsqueda

Rx en el mundo real

Ix (Interactive Expressions) Más allá de Rx

IQbservable <T> Más allá de Rx

Tx Logs y trazas reactivos Más allá de Rx

ReactiveUI UI en Xamarin , UWP y WPF con soporte para Rx https:// github.com/reactiveui Más allá de Rx

Recursos

Código fuente De Rx : https :// github.com/Reactive-Extensions/Rx.NET De esta sesión : https:// github.com/ekapic/Rx-Dns2016 Tutoriales http ://introtorx.com / http:// reactivex.io https :// msdn.microsoft.com/en-us/data/gg577609 Links útiles https:// manning.com/books/reactive-extensions-in-action

http://aka.ms/DOTNETT7S5

Edin Kapić SharePoint Practice Lead @ Sogeti Spain e din @edinkapic.com http://aka.ms/DOTNETT7S5