Filtrado, ordenamiento y agrupamiento en Entity Framework

Una de las características más potentes de Entity Framework es su integración con LINQ (Language Integrated Query), que nos permite escribir consultas directamente en C# de manera intuitiva y segura.

En este artículo, nos centraremos en tres operaciones fundamentales en LINQ: filtrado, ordenamiento y agrupamiento.

Filtrado con Where

El filtrado es una de las operaciones más comunes en cualquier consulta a una base de datos. Nos permite seleccionar solo aquellos registros que cumplen con una condición específica.

En Entity Framework, esto se logra utilizando el método Where.

var resultados = contexto.Entidades.Where(e => e.Propiedad == valor);

Por ejemplo, supongamos que tenemos una entidad Producto con las propiedades Id, Nombre, Precio y Categoria.

var productosElectronicos = contexto.Productos
    .Where(p => p.Categoria == "Electrónica")
    .ToList();

Filtrado con múltiples condiciones

También podemos combinar múltiples condiciones utilizando operadores lógicos como && (AND) y || (OR).

var productosCarosElectronicos = contexto.Productos
    .Where(p => p.Categoria == "Electrónica" && p.Precio > 500)
    .ToList();

Por ejemplo, si queremos obtener productos de la categoría “Electrónica” con un precio mayor a 500, podemos hacer:

Ordenamiento con OrderBy y OrderByDescending

El ordenamiento es otra operación común que nos permite organizar los resultados de una consulta en un orden específico.

En Entity Framework, esto se logra utilizando los métodos OrderBy y OrderByDescending.

var resultados = contexto.Entidades.OrderBy(e => e.Propiedad);

Continuando con nuestro ejemplo de productos, si queremos obtener todos los productos de la categoría “Electrónica” ordenados por precio de menor a mayor, podemos hacer:

var productosOrdenados = contexto.Productos
    .Where(p => p.Categoria == "Electrónica")
    .OrderBy(p => p.Precio)
    .ToList();

Si queremos ordenarlos de mayor a menor, simplemente cambiamos OrderBy por OrderByDescending:

var productosOrdenadosDesc = contexto.Productos
    .Where(p => p.Categoria == "Electrónica")
    .OrderByDescending(p => p.Precio)
    .ToList();

Ordenamiento por múltiples propiedades

Si necesitamos ordenar por más de una propiedad. Para ello, podemos utilizar el método ThenBy o ThenByDescending después de un OrderBy o OrderByDescending.

var productosOrdenadosMultiples = contexto.Productos
    .OrderBy(p => p.Categoria)
    .ThenBy(p => p.Precio)
    .ToList();

Agrupamiento con GroupBy

También podemos agrupar elementos de una colección. Esto es útil cuando queremos realizar operaciones agregadas, como contar, sumar o promediar valores dentro de cada grupo.

Para ello en Entity Framework disponemos del método GroupBy, que agrupa los elementos de la colección según el valor de la propiedad especificada.

var resultados = contexto.Entidades.GroupBy(e => e.Propiedad);

Por ejemplo, supongamos que queremos agrupar los productos por categoría y contar cuántos productos hay en cada categoría. Podemos hacer lo siguiente:

var productosPorCategoria = contexto.Productos
    .GroupBy(p => p.Categoria)
    .Select(g => new
    {
        Categoria = g.Key,
        Cantidad = g.Count()
    })
    .ToList();

Agrupamiento con operaciones agregadas

Además de contar, podemos realizar otras operaciones agregadas, como sumar o promediar valores dentro de cada grupo.

var promedioPrecioPorCategoria = contexto.Productos
    .GroupBy(p => p.Categoria)
    .Select(g => new
    {
        Categoria = g.Key,
        PrecioPromedio = g.Average(p => p.Precio)
    })
    .ToList();

Por ejemplo, si queremos calcular e:::explain l ::: precio promedio de los productos en cada categoría

Combinando filtrado, ordenamiento y agrupamiento

Por supuesto, podemos combinar combinar estas operaciones como queramos para obtener los resultados que necesitemos,

var productosElectronicosPorMarca = contexto.Productos
    .Where(p => p.Categoria == "Electrónica")
    .OrderBy(p => p.Precio)
    .GroupBy(p => p.Marca)
    .Select(g => new
    {
        Marca = g.Key,
        Productos = g.ToList()
    })
    .ToList();