Reactive Extensions – Busqueda IEnumerable to Observable

Llevo ya un tiempo trabajando con las Reactive Extensions, desafortunadamente aun no escribo nada en producción haciendo uso de esta herramienta, pero quiero aprovechar esta serie de entradas para documentar algunos ejemplos de código que pueden resultar útiles y uno que otro apunte de documentación, que en español, aun esta muy escasa.

Breve Introducción

De entrada podríamos definir a Reactive Extensions (Rx) como una librería para crear programas asíncronos y basados en eventos usando las colecciones observables y operadores de LINQ… es claro que esto lo dice todo y no dice nada 🙂 Así que trataré de definirlo como lo he visto y cómo lo medio he entendido.

Por lo general trabajamos con colecciones a las que consultamos y empleamos a través de bucles for-each, una vez consultadas nos olvidamos de éstas, y éstas (Las colecciones) no serán capaces de informar sobre los cambios que sufran, como puede ser, la entrada de nuevos elementos. Estas colecciones serán entendidas como secuencias de datos, estas secuencias de datos pueden ser muy variadas, streams, resquests, responses, eventos… todas estas secuencias son tratadas como observables, y aquí es donde esta la clave, en el patrón observador y su implementación en .Net 4 a través de la IObservale e IObserver. Basando todo en una secuencia de elementos observables y unos actores observadores, quienes serán notificados de los cambios que comuniquen los observados. Adicional Rx incluye tipos de schedulers para poder parametrizar la concurrencia de estas consultas que tienen un origen asíncrono… en resumen podríamos definir a Reactive Extensions mediante la formula: Rx = Observables + LINQ + Schedulers.

Estoy seguro que hasta aquí no se ha entendido nada, y en mi humilde opinión, todo es más claro cuando se ve el código, así que veamos un primer ejemplo para ir entendiendo de que se trata.

Instalando los Reactive Extensions

Se pueden obtener a través de NuGet, consultando por “Reactive Extensions” u obtenerlos en la pagina del producto

Consultando una colección como  observable

En el siguiente ejemplo vamos a realizar una consulta sobre un IEnumerable, que será convertido a una secuencia observable a través del método de extensión .ToObservable()

    public partial class Form1 : Form
    {
        //Colección
        private readonly IEnumerable _words;

        public Form1()
        {
            //Inicialización de la colección
            _words = new List
                     {
                         "Randy",
                         "Santiago",
                         "Sergio",
                         "Nicolas",
                         "Mario"
                     };
            InitializeComponent();
            //Label que mostrará los resultados
            label1.Text = string.Empty;
        }

        //Botón de búsqueda
        private void Button1Click(object sender, EventArgs e)
        {
            //Inicialización de la secuencia obsérvale a partir del resultado del método Search()
            //Se usa el Scheduler Default, se encargará de la asincronía en la ejecución de la consulta,
            //empleando un hilo del threadpool
            //Más sobre Schedulers en proximos posts
            IObservable observable = Search(textBox1.Text).ToObservable(Scheduler.Default);

            //El método Subscribe genera el observador.
            //Se hace uso de Invoke para sincronizar los hilos
            //Cada uno de los parametros del metodo de extensión Subscribe corresponde
            //a los métodos de la interfaz IObserver
            observable.Subscribe(result => Invoke(new Action(() =>
                                                             {
                                                                 label1.Text = string.Format("{0} - {1}", label1.Text,
                                                                     result);
                                                             })),//On Next
                ex => MessageBox.Show(string.Format("OnError{0}", ex.Message)), //OnError
                () => MessageBox.Show("OnComplete")); //OnComplete
        }

        //Metodo de busca
        private IEnumerable Search(string search)
        {
            foreach (string word in _words)
            {
                if (Consulta(word, search)) yield return word;
            }
        }

        //Predicado del Linq, separado para más facilidad en la lectura del código
        private bool Consulta(string s, string parametro)
        {
            //Simula una larga espera y demuestra la asincronía de la búsqueda, pues no se bloquea la interfaz de usuario
            Thread.Sleep(10000);
            return s.StartsWith(parametro);
        }
    }

Al ejecutar el código veremos que la interfaz de usuario no se bloquea y que se van pintando los items según va pasando el tiempo, hasta aquí “no tiene” ningún”” punto interesante o a favor, pues con un poco más de esfuerzo habríamos logrado lo mismo con una colección + Task + Async… Pero este es solo el primer ejemplo.

Hasta el próximo post.

Anuncios
Reactive Extensions – Busqueda IEnumerable to Observable

2 comentarios en “Reactive Extensions – Busqueda IEnumerable to Observable

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s