Alberto Diaz : LINQ, .NET Framework

LINQ. Enigma recursivo

Alberto Diaz Martin — Thu, 09 Dec 2010 11:23:00 GMT

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…

2ª Edición del Curso de Evolución del Acceso a Datos en Tenerife

Alberto Diaz Martin — Fri, 25 Jun 2010 07:31:10 GMT

La semana del 5 de Julio repetiremos el curso en Tenerife sobre la Evolución de la plataforma de Acceso a Datos en .NET.

Algunos se quedaron sin ir a la primera edición y esperamos que esta segunda edición cumpla con las mismas espectativas que el anterior y que sigamos ofreciendo formación en .NET en Tenerife.

Si estáis interesados y necesitáis más información la tenemos en el Centro de Formación de General de Software de Canarias y en el documento del curso.

Curso de Evolución del Acceso a Datos en Tenerife

Alberto Diaz Martin — Sat, 01 May 2010 11:03:00 GMT

La semana del 24 de Mayo se ha organizado un curso en Tenerife sobre la Evolución de la plataforma de Acceso a Datos en .NET y tendré el placer de impartirlo.

Este curso pretende dar a conocer los modelos actuales de acceso a datos en .NET Framework y como aplicarlos para acceder a bases de datos desde los distintos tipos de aplicaciones que permite la plataforma. Nos centraremos en la versión .NET Framework 4.0 y en Visual Studio 2010.

La duración es de 20 horas y el contenido será:

Introducción a ADO.NET
LINQ
LINQ to SQL
Entity Framework
WCF Data Services

Esperamos que sea el primero de una larga serie de cursos en Tenerife orientados a .NET y Visual Studio 2010.

Si estáis interesados y necesitáis más información la tenemos en el Centro de Formación de General de Software de Canarias y en el documento del curso.

Saludos a todos…

EF4. Consultas ordenadas aleatoriamente

Alberto Diaz Martin — Mon, 05 Apr 2010 19:19:24 GMT

Hace unos días @fisica3 intentaba migrar un proyecto en LINQ to SQL a Entity Framework 4. El problema surgía cuando intentaba agregar al modelo una función SQL Server del tipo Composable.

Este tipo de funciones no se pueden mapear en un modelo de entidades, para hacer uso de estas hay que construir el Query con Entity SQL y utilizar las funciones, por ejemplo:

        1: using (var context = new ObjectContext("Name=Entities"))

       2: {

       3:     ObjectQuery<EntidadResult> query = context.CreateQuery<EntidadResult>

       4:         (@"select value c.Nombre, Model.Store.GetApellidos(c.Apellido1, c.Apellidos2) from Entities.Clientes as c");

       5:  

       6:     ObjectResult<EntidadResult> result = query.Execute(MergeOption.NoTracking);

       7:  

       8:     foreach (var item in result)

       9:     {

      10:         Console.WriteLine("{0} {1}", item.Nombre, item.Apellidos);

      11:     }

      12: }

El problema se produce si la función que queremos utilizar es parte de la condición de ordenación, la idea es utilizar una función que devuelve un GUID aleatorio para que la consulta se ordene aleatoriamente.

       1: CREATE FUNCTION [dbo].[GetNewId]()

       2: RETURNS uniqueidentifier

       3: AS

       4: BEGIN

       5:   RETURN (SELECT ID FROM RandomView)

       6: END

       7:  

       8: CREATE VIEW [dbo].[RandomView]

       9: AS

      10: SELECT NEWID() As ID

Si creamos un DataContext con LINQ to SQL y mapeamos la función GetNewId en nuestro modelo, tenemos la posibilidad de realizar nuestra consulta utilizando como ordenación el valor devuelto por la función.

       1: using (var context = new MusicaDataClassesDataContext())

       2: {

       3:     var canciones = from c in context.Canciones

       4:                     orderby context.GetNewId()

       5:                     select c;

       6:  

       7:     foreach (var item in canciones)

       8:     {

       9:         Console.WriteLine("{0} {1}", item.CancionId, item.Album);

      10:     }

      11: }

Entonces, ¿cómo podemos realizar esta consulta con Entity Framework?.

Entity Framework nos permite hacer uso de la expresión LET, que se utiliza para introducir una variable en el ámbito que puede ser utilizado por las siguientes cláusulas de consulta. Similar a las variables locales en un cuerpo de método, esto le da una manera de evitar evaluar una expresión común de varias veces por almacenarlo en una variable. Esto puede ser muy útil incluso en consultas mucho más simples.

Podemos crearnos una consulta con la expresión LET que contengan un valor aleatorio y este sería utilizado para la ordenación (algo parecido a la función que utilizamos en LINQ to SQL).

       1: using (var context = new MusicaEntities())

       2: {

       3:     var musica = from p in context.Canciones

       4:                  let guid = Guid.NewGuid()

       5:                  orderby guid

       6:                  select p;

       7:  

       8:     foreach (var item in musica)

       9:     {

      10:         Console.WriteLine("{0} - {1}", item.CancionId, item.Album);

      11:     }

      12: }

Entity Framework transforma el query anterior, con el let guid = Guid.NewGuid(), en la siguiente sentencia T-SQL, que contiene un subquery con la generación de nuestro GUID.

       1: SELECT 

       2: [Project1].[CancionId] AS [CancionId], [Project1].[Artista] AS [Artista], 

       3: [Project1].[Album] AS [Album], [Project1].[Titulo] AS [Titulo], [Project1].[AñoAlbum] AS [AñoAlbum], 

       4: [Project1].[AñoRanking] AS [AñoRanking], [Project1].[Ubicacion] AS [Ubicacion], [Project1].[Ranking99] AS [Ranking99]

       5: FROM ( SELECT 

       6:     [Extent1].[CancionId] AS [CancionId],     [Extent1].[Artista] AS [Artista], 

       7:     [Extent1].[Album] AS [Album],     [Extent1].[Titulo] AS [Titulo], 

       8:     [Extent1].[AñoAlbum] AS [AñoAlbum],     [Extent1].[AñoRanking] AS [AñoRanking], 

       9:     [Extent1].[Ubicacion] AS [Ubicacion],     [Extent1].[Ranking99] AS [Ranking99], 

      10:     NEWID() AS [C1]

      11:     FROM [dbo].[Canciones] AS [Extent1]

      12: )  AS [Project1]

      13: ORDER BY [Project1].[C1] ASC

Como vemos en la consulta transact, la función del CLR Guid.NewGuid se ha transformado en un NEWID() de T-SQL, con lo que se realiza la ordenación por ese campo aleatorio por fila.

Aunque no podamos utilizar la función que nos devuelve un valor aleatorio del tipo GUID, Entity Framework tiene la herramienta necesaria para realizar este método sin necesidad de utilizar la función.

Saludos a todos…

Operadores LINQ

Alberto Diaz Martin — Tue, 23 Mar 2010 19:37:00 GMT

LINQ (Language INtegrated Query) nos permite escribir consultas (parecidas a consultas SQL) sobre nuestras colecciones (List, IEnumerable, …). Con estos operadores estándares, podremos hacer consultas determinando si existe un tipo de elemento o realizar una suma de la secuencia. Básicamente nos permite filtrar, enumerar y crear proyecciones de varios tipos de colecciones.

En LINQ tenemos un amplio conjunto de operadores. La siguiente tabla muestra los operadores de LINQ y una breve descripción de la funcionalidad que ofrecen.

Operador	Descripción
Agregación
Aggregate	Realiza un método personalizado sobre una secuencia
Average	Calcula el promedio de una secuencia de valores numéricos
Count	Devuelve el número de los elementos de una secuencia como un int
LongCount	Devuelve el número de los elementos de una secuencia como un largo
Min	Encuentra el número mínimo de una secuencia de números
Max	Encuentra el número máximo de una secuencia de números
Sum	Suma de los números en una secuencia

Concatenación
Concat	Concatena dos secuencias en una secuencia

Conversión
Cast	Convierte elementos de una secuencia en otro tipo dado
OfType	Filtra los elementos de una secuencia de un determinado tipo
ToArray	Devuelve un Array de una secuencia
ToDictionary	Devuelve un Dictionary de una secuencia
ToList	Devuelve un List de una secuencia
ToLookup	Devuelve un Lookup de una secuencia
ToSequence	Devuelve un IEnumerable de una secuencia

Elemento
DefaultIfEmpty	Crea un elemento predeterminado para una secuencia vacía
ElementAt	Devuelve el elemento de un índice determinado en una secuencia
ElementAtOrDefault	Devuelve el elemento de un índice determinado en una secuencia o un valor predeterminado si el índice está fuera del intervalo
First	Devuelve el primer elemento de una secuencia
FirstOrDefault	Devuelve el primer elemento de una secuencia o un valor predeterminado si no se encuentra ningún elemento
Last	Devuelve el último elemento de una secuencia
LastOrDefault	Devuelve el último elemento de una secuencia o un valor predeterminado si no se encuentra ningún elemento
Single	Devuelve el único elemento de una secuencia
SingleOrDefault	Devuelve el único elemento de una secuencia o un valor predeterminado si no se encuentra ningún elemento

Igualdad
SequenceEqual	Compara dos secuencias para ver si son equivalentes

Generación
Empty	Genera una secuencia vacía
Range	Genera una secuencia dado un rango
Repeat	Genera una secuencia repitiendo un elemento un número determinado de veces

Agrupación
GroupBy	Agrupa elementos de una secuencia por una agrupación dada

Enlazando
GroupJoin	Realiza una combinación agrupada de dos secuencias
Join	una combinación interna de dos secuencias

Ordenación
OrderBy	Ordena una secuencia por valor (s) en orden ascendente
OrderByDescending	Ordena una secuencia por valor (s) en orden de descendente
ThenBy	Ordena una secuencia que ya se ha ordenado en orden ascendente
ThenByDescending	Ordena una secuencia que ya se ha ordenado en orden descendente
Reverse	Invierte el orden de los elementos de una secuencia

Particionado
Skip	Devuelve una secuencia que omite un número determinado de elementos
SkipWhile	Devuelve una secuencia que omite elementos que no cumplen una expresión
Take	Devuelve una secuencia que toma un número determinado de elementos
TakeWhile	Devuelve una secuencia que toma elementos que cumplen una expresión

Proyección
Select	Crea una proyección a partir de una secuencia
SelectMany	Crea una proyección One to Many de elementos de una secuencia

Cuantificadores
All	Determina si todos los elementos de una secuencia cumplen una condición
Any	Determina si los elementos de una secuencia cumplen una condición
Contains	Determina si una secuencia contiene un elemento determinado

Restricción
Where	Filtra los elementos de una secuencia

Conjuntos
Distinct	Devuelve una secuencia sin elementos duplicados
Except	Devuelve una secuencia que representa la diferencia entre dos secuencias
Intersect	Devuelve una secuencia que representa la intersección de dos secuencias
Union	Devuelve una secuencia que representa la unión de dos secuencias

Vamos a ver algunos ejemplos de código:

Average

   1:  int[] nums = new int[] {1,2,3,4,5,6,7,8,9};

   2:  double avg = nums.Average();

Calculamos la media de los enteros del array.

Where

   1:  IEnumerable<Customer> customersInTenerife = customers.Where(c => c.City == "Tenerife");

Buscamos los clientes cuya ciudad sea Tenerife.

Take

   1:  IEnumerable<Product> MostExpensive10 =

   2:      products.OrderByDescending(p => p.UnitPrice).Take(10);

En este ejemplo, ordenamos los productos descendentemente por UnitPrice y luego

seleccionamos 10 productos.

Skip

   1:  IEnumerable<Product> AllButMostExpensive10 =

   2:      products.OrderByDescending(p => p.UnitPrice).Skip(10);

Aquí ordenamos, de nuevo, descendentemente por UnitPrice y seleccionamos todos los elementos menos los 10 más caros.

Join

   1:  var custOrders =

   2:      customers.Join(orders, c => c.CustomerID, o => o.CustomerID,

   3:                               (c, o) => new { c.Name, o.OrderDate, o.Total }

   4:                                );

Enlazamos los clientes con sus facturas y devolvemos una lista con el nombre del cliente, la fecha de la factura y el total facturado.

OrderBy/ThenBy

   1:  IEnumerable<Product> orderedProducts =

   2:      products.OrderBy(p => p.Category).

   3:                     ThenByDescending(p => p.UnitPrice).

   4:                     ThenBy(p => p.Name);

La siguiente consulta ordena la lista de productos por Category, luego por UnitPrice descendiente y por último por Name.

GroupBy

   1:  IEnumerable<IGrouping<string, Product>> productsByCategory =

   2:      products.GroupBy(p => p.Category);

Podemos agrupar los productos y obtener un IEnumerable agrupado que contenga la Category y los productos que corresponden a esa Category.

ToDictionary

   1:  Dictionary<int,Order> orders =

   2:      customers.SelectMany(c => c.Orders).

   3:                Where(o => o.OrderDate.Year == 2005).

   4:                ToDictionary(o => o.OrderID);

Creamos un Dictionary seleccionando las Facturas de los clientes del año 2005, utilizando como clave el OrderID.

Any

   1:  bool result = customers.Any(c => c.Name == "Pepe");

Devuelve True si encuentra algún cliente con el Name Pepe.

ForEach

   1:  List<customer> customers = GetCustomers();

   2:  customers.ForEach(p => Insertar(p));

Para cada cliente de la lista customers, ejecutamos el método Insertar pasándole por parámetro el elemento actual.

Si queremos más información sobre LINQ, lo mejor es pasarse por la MSDN y leernos la documentación o alguno de los tutoriales que tenemos sobre él.

Este es uno de los grandes avances que Microsoft incluyó con el Framework 3.5 y que nos facilita bastante la vida y nos permite programar mejor y más rápido.

Espero que disfrutéis tanto como yo escribiendo código y que lo hagáis más con LINQ, os lo recomiendo.

Saludos a todos…