Reactive Extensions (#codemotion)

El pasado fin de semana @quiqu3 y @fernandoescolar estuvieron en Madrid, en la codemotion, en representación de programando en .net. Además tuvieron el placer de impartir una pequeña charla de 45 minutos acerca de las reactive extensions. Aprovechando este hecho, nos gustaría cerrar de una forma más o menos elegante la serie de artículos sobre rx, aportando un índice de los artículos, un breve resumen basado en la charla y varios programas de ejemplo (incluida la red social de moda: BeerToBeer).

Reactive extensions

Las reactive extensions es el nombre que recibe una framework que nos ayudará a desarrollar de una forma novedosa y cercana al lenguaje natural. Fueron creadas por Eric Meijer, el padre de Linq. Y basa su forma de trabajar en esta herramienta.

Cuando hablamos de Linq (Language Integrated Query) nos referimos a una librería de la framework .net de Microsoft que nos ayuda a operar con colecciones, listas, diccionarios,… en resumen: enumeraciones mediante un lenguaje de interfaces fluent.

Cuando hablamos de interfaces fluent (nombre acuñado por el propio Eric Evans y Martin Fowler), es hablar de un tipo de implementación de la programación orientada a objetos que nos ayuda a crear código fuente más legible. Se basa en crear métodos dentro de objetos que nos devuelven al propio objeto que las usa. De esta forma podemos encadenar varias llamadas encadenadas por puntos. Pero mejor vamos a ver un ejemplo:

public class FluentClass
{
    private int value;

    public FluentClass WithValue(int value) { this.value = value; return this; }

    public FluentClass AddOne() { this.value += 1; return this; }

    public FluentClass SubstractTwo() { this.value -= 2; return this; }

    public FluentClass MultiplyThree() { this.value *= 3; return this; }

    public FluentClass DrawValue() { Console.WriteLine(this.value); return this; }
}

static void Main(string[] args)
{
    var fluent = new FluentClass()
                        .WithValue(9)
                        .DrawValue()
                        .AddOne()
                        .DrawValue()
                        .SubstractTwo()
                        .DrawValue()
                        .MultiplyThree()
                        .DrawValue();

    Console.ReadLine();
}

Como se puede observar en este ejemplo, cada función del objeto fluent, después de operar devuelve el propio objeto. Esto unido con nombre de función muy descriptivos, hacen que podamos crear una serie de llamadas encadenadas, cuyo significado es muy legible.

Una vez hemos visto esto, podemos entonces acercarnos a cómo Linq, usando esta forma de programar, nos ayuda a realizar búsquedas, filtrados, ordenaciones y demás operaciones; con conjuntos de valores en .net:

static void Main()
{
    var lista = new List<int> {3, 4, 5, 78, 89, 98, 123, 2, 3};

    var listaFiltrada = lista
                            .OrderByDescending(x => x) // ordena de forma inversa
                            .Where(x => x < 50) // filtra los valores menores de 50
                            .Take(2); // coge los dos primeros

    // este código dibujará en pantalla un 5 y un 4
    foreach (var item in listaFiltrada)
    {
        Console.WriteLine(item);
    }

    Console.ReadLine();
}

En este otro ejemplo podemos ver como aplicamos algoritmos de ordenación, de filtrado y selección usando este Linq.

Y así vamos llegando hasta el contexto actual de aplicación:

contexto de aplicación actual

Lo que nos podemos encontrar actualmente son aplicaciones distribuidas. Pongamos el ejemplo de twitter, donde encontramos unos servicios que están alojados en la nube y una serie de clientes diferentes según sean plataformas móviles, páginas web o aplicaciones de escritorio.

Todas estas aplicaciones usan los mismos servicios que son quienes manejan los datos. Para comunicarse con ellos se utiliza un tipo de comunicación asíncrona, con lo que conseguimos que nuestra aplicación no se quede congelada esperando una respuesta del servidor. Y para gestionar la interacción con el usuario se utilizan los eventos.

Es decir, nuestras aplicaciones convierten eventos en llamadas a servicios. Pero la forma de manejar unos y otros es muy diferentes y es justo en este punto en el que aparecen las reactive extensions y encontramos su objetivo: unificar la forma de gestionar eventos y las llamadas a servicios.

Para conseguir esta compleja tarea se recurre a la programación reactiva. Un nuevo paradigma de programación que podemos decir que se diferencia de la programación tradicional en que es un sistema Push y no Pull. Es decir el código en la forma de programación tradicional se maneja bajo demanda (cada vez que escribimos una línea) y en la programación reactiva, se evalúa código cuando un acontecimiento que tiene relación con él ocurre (como las notificaciones Push del móvil).

Y es aquí cuando llegamos a una nueva problemática, la de programar de forma reactiva usando un lenguaje secuencial. La solución nos la aporta esta función que definen las reactive extensions y que nos brindan desde los Microsoft Live Labs:

Formula de las reactive extensions

Para poder explicar esta formula de una forma cercana a la programación hemos creado una aplicación: BeerToBeer, que ya mostramos en la codemotion. Una red social (tipo twitter) en la que puedes enviar mensajes a propósito de la cerveza que estás bebiendo en ese momento.

El ejemplo está compuesto de una serie de servicios WCF (con netTcp, http y REST) y unos clientes para tres plataformas diferentes: HTML 5, Windows Phone 7 y Windows (WPF).

Descargas de material

Entre los materiales de la charla se encuentra la presentación que mostramos y la aplicación de ejemplo BeerToBeer con el código de servicios y los clientes. Además también podréis encontrar otros ejemplos que no mostramos como un EventAggregator reactivo, el típico ejemplo de Drag ‘n Drop o un mini cliente twitter.

Descargar el ejemplo

La presentación que mostramos

 

Y si crees que las reactive extensions pueden serte de utilidad en tu trabajo o simplemente quieres saber más sobre las mismas, no olvides que en esta misma web tenemos una serie de cinco artículos donde se trata a fondo esta framework.

Índice de artículos

  1. Qué son las reactive extensions
  2. Observables (los sujetos)
  3. Linq: crear objetos observables
  4. Linq: operaciones con observables
  5. Schedulers y Linq2Events