Lo tengo que reconocer, soy un viciado de las consultas SQL. Me recuerdan a los problemas de lógica en los que tenías que averiguar quién hace qué y cómo, y resolver un enigma.

Pues así veo las consultas SQL, como un enigma a resolver. Me he pasado horas dándole vueltas a las consultas para hacer joins imposibles y subconsultas buscando obtener los datos en una sola llamada y con el mejor rendimiento posible. La verdad es que, a veces, echo de menos esas consultas de varias páginas tiradas en el Administrador de consultas del SQL Server 6.5 o 2000.

Con el tiempo vas evolucionando y te vas pasando a los ORM (Hibernate, LINQ to SQL, Entity Framework, LLBLGEN), y dejas de lanzar esas consultas y simplificas la lógica para que se adapten a las entidades, aún así seguías queriendo meter código en procedimientos almacenados para no olvidar aquella parte de ti, que controlas y que te gusta.

Desde que nació LINQ me pareció el gran avance de la programación actual. Cuando lo empiezas a usar, te das cuenta que vas a dejar de echar de menos a aquellas consultas y empiezas a olvidarte de los procedimiento almacenados. Pasas a otro nivel.

En ese nivel, empiezas a lanzar consultas sobre listas, enumerados y colecciones (y a todo lo que te echen por delante, que si no es consultable buscas la forma de que lo sea), y empieza a aparecer, de nuevo, los enigmas de aquellas consultas SQL, ahora en C#.

No lo puedo evitar y busco siempre la mejor consulta y la más eficiente, incluso me pongo a calcular el rendimiento de hacerla con LINQ y sin LINQ.

El último reto fue hacer una búsqueda recursiva, a través de listas de elementos enlazados con listas de esos elementos, utilizando LINQ.  Partimos de la siguiente clase que contiene una lista de elementos hijos de su misma clase.

public class Organizacion

{

    public Guid ID { get; set; }

    public OrganizationProfile Profile { get; set; }

    public string DisplayName { get; set; }

    public Organizacion Parent { get; set; }

    public List<Organizacion> Childs { get; set; }

    public UserProfile Leader { get; set; }

    public List<UserProfile> Members { get; set; }

}

Necesitábamos realizar una búsqueda recurrente en la lista principal que a su vez hiciera la misma búsqueda en los hijos (List<Organizacion> Childs) que a su vez buscara en los hijos de los hijos de los hijos… y así sucesivamente.

Este problema lo solucionaríamos con una búsqueda recursiva que fuera recorriendo todos los elementos, bajando y realizando la búsqueda en cada lista de hijos que fuera encontrando.

Cómo no me puedo estar quieto, me puse a buscar una solución que me permitiera hacer esa búsqueda en una consulta LINQ y ya llegué a la solución de crearme un método extensor que utiliza el combinador Y para realizar lambdas recursivas. Este método quedó tal como sigue:

private delegate Func<A, R> Recursive<A, R>(Recursive<A, R> r);

private static Func<A, R> Y<A, R>(Func<Func<A, R>, Func<A, R>> f)

{

    Recursive<A, R> rec = r => a => f(r(r))(a); return rec(rec);

}

public static IEnumerable<Organizacion> Recorrer(this IEnumerable<Organizacion> source, Func<Organizacion, bool> function)

{

    var traverse = Extensions.Y<IEnumerable<Organizacion>, IEnumerable<Organizacion>>(

        f => items =>

        {

            var r = new List<Organizacion>(items.Where(function));

            r.AddRange(items.SelectMany(i => f(i.Childs)));

            return r;

        });

    return traverse(source);

}

Nos creamos un delegado de la función recursiva (Y) y la función que recorre todos los elementos navegando por la lista de Childs y devolviendo un enumerable de todos los elementos de todas las listas.

Con lo que es muy sencillo y limpio (además de bonito y satisfactorio ) hacer la consulta para encontrar un elemento de todas las colecciones, utilizando el método extensor.

Organizacion parentOrg = OrganizacionList.Recorrer(o => o.DisplayName == manager["Department"].ToString()).FirstOrDefault();

Lo sé, debería de pasar más tiempo haciendo otras cosas más útiles, pero, y lo bien que me lo he pasado….

Saludos a todos…