Introducción a la programación reactiva con Rx

La programación reactiva es un paradigma orientado a flujos de datos y a la propagación de cambios. En lugar de preguntar continuamente si ha ocurrido algo, describimos cómo reaccionar cuando llega un nuevo valor.

El mundo real no siempre es secuencial. Muchos sistemas reciben información de forma asíncrona. El usuario hace clic cuando quiere, el servidor responde cuando puede, y el GPS nos envía coordenadas cuando le da la gana.

Intentar modelar esto con bucles while o con el infierno de los callbacks es doloroso. Ahí encaja la Programación Reactiva.

En lugar de pedir datos (Pull), nos sentamos a esperar a que los datos vengan a nosotros (Push), y reaccionamos a ellos.

Qué es la programación reactiva

Definición formal:

La programación reactiva modela valores que cambian y propaga esos cambios a quienes dependen de ellos.

Con bibliotecas como Rx podemos tratar un clic, un temporizador o una respuesta HTTP como un flujo de eventos. No todo flujo reactivo tiene que ser asíncrono, aunque ese sea uno de sus usos más frecuentes.

Y lo mejor de todo: podemos aplicarles operadores funcionales. Sí, los mismos que vimos en el artículo anterior (Map, Filter, Scan).

Los componentes de Rx (Reactive Extensions)

La implementación más famosa de este paradigma es la familia Reactive Extensions (Rx), disponible en casi todos los lenguajes (RxJS, Rx.NET, RxJava/Kotlin).

Rx combina ideas de dos interfaces conocidas:

En Rx, tenemos tres actores principales:

Ejemplo práctico: el buscador predictivo

Vamos a ver el caso de uso por excelencia: La barra de búsqueda. Queremos que, cuando el usuario escriba, busquemos en el servidor. Pero con condiciones:

• No buscar si el texto tiene menos de tres letras.
• Esperar a que el usuario deje de escribir para no lanzar una petición por tecla.
• No repetir dos búsquedas consecutivas con el mismo texto.
• Ignorar el resultado anterior si comienza una búsqueda nueva.

La versión imperativa con callbacks y timers

(Es pseudocódigo para ilustrar la gestión manual; no pretende compilar.)

// ❌ CÓDIGO IMPERATIVO "SPAGHETTI"
private Timer _timer;
private string _ultimaBusqueda;

void OnTextChanged(string texto) {
    if (texto.Length < 3) return;

    // Gestión manual del timer para el debounce
    if (_timer != null) _timer.Stop();
    _timer = new Timer(500);
    _timer.Elapsed += (s, e) => {
        if (texto == _ultimaBusqueda) return;
        _ultimaBusqueda = texto;

        LlamarApi(texto, (resultado) => {
             // Cuidado con condiciones de carrera aquí...
             // ¿Y si llega otra respuesta antes? ¡Caos!
             Mostrar(resultado);
        });
    };
    _timer.Start();
}

La versión reactiva con Rx.NET

Usando System.Reactive y LINQ.

// ✅ CÓDIGO REACTIVO
// Convertimos el evento de UI en un Observable (un flujo de strings)
var busquedas = Observable.FromEventPattern<TextChangedEventArgs>(txtBuscar, "TextChanged")
    .Select(evt => ((TextBox)evt.Sender).Text) // Extraemos el texto
    .Throttle(TimeSpan.FromMilliseconds(500))  // Esperamos 500ms de silencio (Debounce)
    .Where(texto => texto.Length >= 3)         // Filtramos textos cortos
    .DistinctUntilChanged()                    // Ignoramos si es igual al anterior
    .Select(texto => LlamarApi(texto))         // Proyectamos a la llamada API
    .Switch();                                 // Si llega una nueva, cancela la anterior

// Nos suscribimos al resultado final
busquedas.Subscribe(resultado => {
    Console.WriteLine($"Resultados recibidos: {resultado.Count}");
});

Observables hot y cold

Este es un concepto técnico que suele confundir al principio.

• Cold observables (fríos): son como reproducir una película bajo demanda. La secuencia comienza al suscribirte y cada suscriptor obtiene su propia ejecución.

• Ejemplo: una llamada HTTP o la lectura de un archivo.

• Hot observables (calientes): son como la radio o un partido en directo. La emisión ocurre independientemente de tu suscripción y, si llegas tarde, te pierdes el principio.

• Ejemplo: los clics del ratón o una cotización en tiempo real.