Agregación (Count, Sum)

Las operaciones de agregación en LINQ permiten realizar cálculos sobre colecciones de datos, reduciendo múltiples valores a un único resultado. Estas operaciones son fundamentales cuando necesitamos obtener estadísticas o resúmenes de nuestros datos.

Operador Count

El operador Count nos permite determinar el número de elementos en una colección, opcionalmente aplicando un criterio de filtrado. Es especialmente útil cuando necesitamos saber cuántos elementos cumplen con una condición específica.

Veamos algunos ejemplos prácticos:

// Lista de productos para los ejemplos
var productos = new List<Producto>
{
    new Producto { Id = 1, Nombre = "Laptop", Precio = 1200, Categoria = "Electrónica" },
    new Producto { Id = 2, Nombre = "Monitor", Precio = 300, Categoria = "Electrónica" },
    new Producto { Id = 3, Nombre = "Teclado", Precio = 80, Categoria = "Periféricos" },
    new Producto { Id = 4, Nombre = "Mouse", Precio = 25, Categoria = "Periféricos" },
    new Producto { Id = 5, Nombre = "Impresora", Precio = 150, Categoria = "Oficina" }
};

Contar todos los elementos de la colección:

// Contar todos los productos
int totalProductos = (from p in productos
                      select p).Count();

// Forma alternativa más concisa
int totalProductos = productos.Count();

Console.WriteLine($"Total de productos: {totalProductos}"); // Resultado: 5

Contar elementos que cumplen una condición:

// Contar productos de la categoría "Electrónica"
int productosElectronica = (from p in productos
                           where p.Categoria == "Electrónica"
                           select p).Count();

// Forma alternativa con lambda en el Count
int productosElectronica = productos.Count(p => p.Categoria == "Electrónica");

Console.WriteLine($"Productos de electrónica: {productosElectronica}"); // Resultado: 2

Operador Sum

El operador Sum calcula la suma total de valores numéricos en una colección. Podemos sumar directamente los elementos si son de tipo numérico, o especificar una expresión que devuelva un valor numérico para cada elemento.

Ejemplos de uso del operador Sum:

// Calcular el precio total de todos los productos
decimal precioTotal = (from p in productos
                       select p.Precio).Sum();

// Forma alternativa más concisa
decimal precioTotal = productos.Sum(p => p.Precio);

Console.WriteLine($"Precio total de todos los productos: ${precioTotal}"); // Resultado: $1755

Podemos combinar Sum con filtros para calcular sumas parciales:

// Calcular el precio total de productos de periféricos
decimal precioPerifericos = (from p in productos
                            where p.Categoria == "Periféricos"
                            select p.Precio).Sum();

// Forma alternativa
decimal precioPerifericos = productos
    .Where(p => p.Categoria == "Periféricos")
    .Sum(p => p.Precio);

Console.WriteLine($"Precio total de periféricos: ${precioPerifericos}"); // Resultado: $105

Combinando operadores de agregación con agrupación

Podemos combinar estos operadores con agrupaciones para obtener estadísticas más elaboradas:

// Calcular el precio total por categoría
var preciosPorCategoria = from p in productos
                         group p by p.Categoria into g
                         select new {
                             Categoria = g.Key,
                             PrecioTotal = g.Sum(p => p.Precio),
                             CantidadProductos = g.Count()
                         };

foreach (var grupo in preciosPorCategoria)
{
    Console.WriteLine($"Categoría: {grupo.Categoria}");
    Console.WriteLine($"  Cantidad de productos: {grupo.CantidadProductos}");
    Console.WriteLine($"  Precio total: ${grupo.PrecioTotal}");
}

Este código generará una salida como:

Categoría: Electrónica
  Cantidad de productos: 2
  Precio total: $1500

Categoría: Periféricos
  Cantidad de productos: 2
  Precio total: $105

Categoría: Oficina
  Cantidad de productos: 1
  Precio total: $150

Manejo de colecciones vacías

Un aspecto importante a considerar es el comportamiento de estos operadores con colecciones vacías:

var listaVacia = new List<int>();

// Count siempre es seguro con colecciones vacías
int contador = listaVacia.Count(); // Resultado: 0

// Sum con colección vacía devuelve el valor por defecto del tipo numérico
int suma = listaVacia.Sum(); // Resultado: 0 (valor por defecto de int)

// Para tipos decimales, el valor por defecto también es 0
decimal sumaDecimal = new List<decimal>().Sum(); // Resultado: 0.0m

Otros operadores de agregación útiles

Aunque nos estamos enfocando en Count y Sum, es importante mencionar que LINQ ofrece otros operadores de agregación complementarios:

// Obtener el precio más alto
decimal precioMaximo = productos.Max(p => p.Precio); // 1200

// Obtener el precio más bajo
decimal precioMinimo = productos.Min(p => p.Precio); // 25

// Calcular el precio promedio
decimal precioPromedio = productos.Average(p => p.Precio); // 351

Estos operadores de agregación son herramientas poderosas que simplifican enormemente el código necesario para realizar cálculos estadísticos sobre colecciones, permitiéndonos expresar operaciones complejas de manera concisa y legible.

La clase Producto utilizada en los ejemplos podría definirse así:

public class Producto
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public decimal Precio { get; set; }
    public string Categoria { get; set; }
}

Agrupación con GroupBy

La agrupación de datos es una operación fundamental cuando trabajamos con colecciones en C#. El operador GroupBy de LINQ nos permite organizar elementos en grupos según una o más propiedades, facilitando el análisis y procesamiento de información relacionada.

Concepto básico de agrupación

Cuando agrupamos datos, estamos creando subconjuntos de elementos que comparten un valor común para una propiedad específica. Cada grupo contiene:

• Una clave que identifica al grupo (el valor común)
• Una colección de elementos que pertenecen a ese grupo

Veamos un ejemplo sencillo utilizando una lista de productos:

// Lista de productos para los ejemplos
var productos = new List<Producto>
{
    new Producto { Id = 1, Nombre = "Laptop", Precio = 1200, Categoria = "Electrónica" },
    new Producto { Id = 2, Nombre = "Monitor", Precio = 300, Categoria = "Electrónica" },
    new Producto { Id = 3, Nombre = "Teclado", Precio = 80, Categoria = "Periféricos" },
    new Producto { Id = 4, Nombre = "Mouse", Precio = 25, Categoria = "Periféricos" },
    new Producto { Id = 5, Nombre = "Impresora", Precio = 150, Categoria = "Oficina" }
};

Sintaxis básica de GroupBy

Podemos agrupar los productos por categoría utilizando la sintaxis de consulta de LINQ:

// Agrupar productos por categoría
var productosPorCategoria = from p in productos
                           group p by p.Categoria;

// Recorrer los grupos
foreach (var grupo in productosPorCategoria)
{
    Console.WriteLine($"Categoría: {grupo.Key}");
    
    foreach (var producto in grupo)
    {
        Console.WriteLine($"  - {producto.Nombre} (${producto.Precio})");
    }
    Console.WriteLine();
}

Este código generará una salida como:

Categoría: Electrónica
  - Laptop ($1200)
  - Monitor ($300)

Categoría: Periféricos
  - Teclado ($80)
  - Mouse ($25)

Categoría: Oficina
  - Impresora ($150)

Proyección de resultados agrupados

En muchos casos, no necesitamos todos los datos de cada elemento, sino un resumen de cada grupo. Podemos crear objetos anónimos que contengan solo la información relevante:

// Crear resumen de cada grupo
var resumenPorCategoria = from p in productos
                         group p by p.Categoria into g
                         select new {
                             Categoria = g.Key,
                             CantidadProductos = g.Count(),
                             ProductosMasBaratos = g.OrderBy(p => p.Precio).Take(1)
                         };

foreach (var resumen in resumenPorCategoria)
{
    Console.WriteLine($"Categoría: {resumen.Categoria}");
    Console.WriteLine($"  Cantidad de productos: {resumen.CantidadProductos}");
    Console.WriteLine("  Producto más barato:");
    
    foreach (var producto in resumen.ProductosMasBaratos)
    {
        Console.WriteLine($"    - {producto.Nombre} (${producto.Precio})");
    }
}

Agrupación por múltiples propiedades

También podemos agrupar por múltiples criterios creando una clave compuesta:

// Ampliamos nuestro ejemplo con más productos
productos.Add(new Producto { Id = 6, Nombre = "Tablet", Precio = 350, Categoria = "Electrónica" });
productos.Add(new Producto { Id = 7, Nombre = "Auriculares", Precio = 75, Categoria = "Periféricos" });

// Agrupar por categoría y rango de precio
var productosPorCategoriaYPrecio = from p in productos
                                  let rangoPrecios = p.Precio < 100 ? "Económico" : 
                                                    (p.Precio < 500 ? "Medio" : "Premium")
                                  group p by new { p.Categoria, Rango = rangoPrecios } into g
                                  select new {
                                      Categoria = g.Key.Categoria,
                                      RangoPrecio = g.Key.Rango,
                                      Productos = g.ToList()
                                  };

foreach (var grupo in productosPorCategoriaYPrecio)
{
    Console.WriteLine($"Categoría: {grupo.Categoria}, Rango: {grupo.RangoPrecio}");
    foreach (var producto in grupo.Productos)
    {
        Console.WriteLine($"  - {producto.Nombre} (${producto.Precio})");
    }
}

Uso de GroupBy con sintaxis de método

Además de la sintaxis de consulta, podemos utilizar la sintaxis de método que algunos desarrolladores prefieren por su concisión:

// Agrupar productos por categoría usando sintaxis de método
var gruposPorCategoria = productos
    .GroupBy(p => p.Categoria)
    .Select(g => new {
        Categoria = g.Key,
        Productos = g.ToList(),
        CantidadProductos = g.Count()
    });

foreach (var grupo in gruposPorCategoria)
{
    Console.WriteLine($"Categoría: {grupo.Categoria} ({grupo.CantidadProductos} productos)");
    foreach (var producto in grupo.Productos)
    {
        Console.WriteLine($"  - {producto.Nombre}");
    }
}

Ordenamiento de grupos

Podemos ordenar los grupos según diferentes criterios, como el número de elementos en cada grupo:

// Ordenar grupos por cantidad de productos (descendente)
var gruposOrdenados = productos
    .GroupBy(p => p.Categoria)
    .Select(g => new {
        Categoria = g.Key,
        Productos = g.ToList(),
        CantidadProductos = g.Count()
    })
    .OrderByDescending(g => g.CantidadProductos);

foreach (var grupo in gruposOrdenados)
{
    Console.WriteLine($"Categoría: {grupo.Categoria} ({grupo.CantidadProductos} productos)");
}

Aplicaciones prácticas de GroupBy

La agrupación es especialmente útil en escenarios de análisis de datos:

// Ejemplo: Análisis de ventas
var ventas = new List<Venta>
{
    new Venta { Producto = "Laptop", Fecha = new DateTime(2023, 1, 15), Cantidad = 2, Total = 2400 },
    new Venta { Producto = "Monitor", Fecha = new DateTime(2023, 1, 15), Cantidad = 3, Total = 900 },
    new Venta { Producto = "Teclado", Fecha = new DateTime(2023, 1, 16), Cantidad = 5, Total = 400 },
    new Venta { Producto = "Mouse", Fecha = new DateTime(2023, 1, 16), Cantidad = 10, Total = 250 },
    new Venta { Producto = "Laptop", Fecha = new DateTime(2023, 1, 17), Cantidad = 1, Total = 1200 }
};

// Ventas agrupadas por día
var ventasPorDia = from v in ventas
                  group v by v.Fecha.Date into g
                  select new {
                      Fecha = g.Key,
                      TotalVentas = g.Sum(v => v.Total),
                      CantidadProductos = g.Sum(v => v.Cantidad)
                  };

foreach (var dia in ventasPorDia)
{
    Console.WriteLine($"Fecha: {dia.Fecha.ToShortDateString()}");
    Console.WriteLine($"  Total vendido: ${dia.TotalVentas}");
    Console.WriteLine($"  Productos vendidos: {dia.CantidadProductos}");
}

Consideraciones de rendimiento

Al trabajar con agrupaciones, es importante tener en cuenta algunas consideraciones de rendimiento:

• Las operaciones de agrupación requieren recorrer toda la colección, lo que puede ser costoso con grandes volúmenes de datos.
• La clave de agrupación debe ser un valor que se pueda comparar eficientemente.
• Si necesitas acceder a los grupos múltiples veces, considera materializar los resultados con ToList() o ToDictionary().

// Materializar los grupos para acceso eficiente
var gruposMaterializados = productos
    .GroupBy(p => p.Categoria)
    .ToDictionary(g => g.Key, g => g.ToList());

// Ahora podemos acceder directamente a un grupo específico
if (gruposMaterializados.TryGetValue("Electrónica", out var productosElectronicos))
{
    Console.WriteLine($"Productos de electrónica: {productosElectronicos.Count}");
}

La clase Venta utilizada en los ejemplos podría definirse así:

public class Venta
{
    public string Producto { get; set; }
    public DateTime Fecha { get; set; }
    public int Cantidad { get; set; }
    public decimal Total { get; set; }
}

El operador GroupBy es una herramienta esencial para el análisis de datos en C#, permitiéndonos transformar colecciones planas en estructuras jerárquicas organizadas según los criterios que necesitemos para nuestro análisis.

Join entre colecciones

Las operaciones de unión (join) en LINQ nos permiten combinar datos de múltiples colecciones basándonos en valores relacionados. Esta funcionalidad es similar a los joins de SQL y resulta esencial cuando trabajamos con datos que están distribuidos en diferentes estructuras pero necesitan ser analizados conjuntamente.

Concepto básico de Join

Un join en LINQ conecta elementos de dos colecciones cuando coinciden según una condición específica. Para entender mejor cómo funcionan, veamos un escenario común: tenemos una colección de clientes y otra de pedidos, y queremos combinar la información de ambas.

Primero, definamos nuestras colecciones de ejemplo:

// Colección de clientes
var clientes = new List<Cliente>
{
    new Cliente { Id = 1, Nombre = "Ana García", Ciudad = "Madrid" },
    new Cliente { Id = 2, Nombre = "Carlos López", Ciudad = "Barcelona" },
    new Cliente { Id = 3, Nombre = "María Rodríguez", Ciudad = "Valencia" },
    new Cliente { Id = 4, Nombre = "Juan Martínez", Ciudad = "Sevilla" }
};

// Colección de pedidos
var pedidos = new List<Pedido>
{
    new Pedido { Id = 101, ClienteId = 1, Producto = "Laptop", Importe = 1200 },
    new Pedido { Id = 102, ClienteId = 3, Producto = "Monitor", Importe = 300 },
    new Pedido { Id = 103, ClienteId = 1, Producto = "Teclado", Importe = 80 },
    new Pedido { Id = 104, ClienteId = 2, Producto = "Impresora", Importe = 150 },
    new Pedido { Id = 105, ClienteId = 3, Producto = "Mouse", Importe = 25 }
};

Join interno (Inner Join)

El join interno es el tipo más común y devuelve elementos cuando hay coincidencia en ambas colecciones:

// Unir clientes con sus pedidos
var clientesConPedidos = from c in clientes
                         join p in pedidos on c.Id equals p.ClienteId
                         select new {
                             Cliente = c.Nombre,
                             Ciudad = c.Ciudad,
                             Producto = p.Producto,
                             Importe = p.Importe
                         };

// Mostrar los resultados
foreach (var item in clientesConPedidos)
{
    Console.WriteLine($"Cliente: {item.Cliente} ({item.Ciudad})");
    Console.WriteLine($"  Producto: {item.Producto}, Importe: ${item.Importe}");
}

Este código generará una salida como:

Cliente: Ana García (Madrid)
  Producto: Laptop, Importe: $1200
Cliente: Ana García (Madrid)
  Producto: Teclado, Importe: $80
Cliente: Carlos López (Barcelona)
  Producto: Impresora, Importe: $150
Cliente: María Rodríguez (Valencia)
  Producto: Monitor, Importe: $300
Cliente: María Rodríguez (Valencia)
  Producto: Mouse, Importe: $25

Observa que Juan Martínez no aparece en los resultados porque no tiene ningún pedido asociado.

Join con sintaxis de método

También podemos realizar el mismo join utilizando la sintaxis de método:

var clientesConPedidos = clientes
    .Join(
        pedidos,
        cliente => cliente.Id,
        pedido => pedido.ClienteId,
        (cliente, pedido) => new {
            Cliente = cliente.Nombre,
            Ciudad = cliente.Ciudad,
            Producto = pedido.Producto,
            Importe = pedido.Importe
        }
    );

Agrupando resultados de un Join

A menudo, queremos agrupar los resultados para tener una vista más organizada. Por ejemplo, podemos listar cada cliente con todos sus pedidos:

var clientesConSusPedidos = from c in clientes
                           join p in pedidos on c.Id equals p.ClienteId
                           group p by c into clienteConPedidos
                           select new {
                               Cliente = clienteConPedidos.Key.Nombre,
                               Ciudad = clienteConPedidos.Key.Ciudad,
                               Pedidos = clienteConPedidos.ToList()
                           };

foreach (var cliente in clientesConSusPedidos)
{
    Console.WriteLine($"Cliente: {cliente.Cliente} ({cliente.Ciudad})");
    Console.WriteLine($"  Pedidos: {cliente.Pedidos.Count}");
    
    foreach (var pedido in cliente.Pedidos)
    {
        Console.WriteLine($"    - {pedido.Producto}: ${pedido.Importe}");
    }
}

Join externo izquierdo (Left Join)

A diferencia de SQL, LINQ no tiene un operador directo para left join, pero podemos simularlo usando GroupJoin y SelectMany:

// Left Join: Todos los clientes, incluso los que no tienen pedidos
var todosLosClientes = from c in clientes
                       join p in pedidos on c.Id equals p.ClienteId into clientePedidos
                       from cp in clientePedidos.DefaultIfEmpty()
                       select new {
                           Cliente = c.Nombre,
                           Ciudad = c.Ciudad,
                           Producto = cp?.Producto ?? "Sin pedidos",
                           Importe = cp?.Importe ?? 0
                       };

foreach (var item in todosLosClientes)
{
    Console.WriteLine($"Cliente: {item.Cliente} ({item.Ciudad})");
    Console.WriteLine($"  Producto: {item.Producto}, Importe: ${item.Importe}");
}

Ahora Juan Martínez aparecerá en los resultados con "Sin pedidos" como producto.

Join con múltiples condiciones

En ocasiones necesitamos unir colecciones basándonos en más de una condición:

// Añadimos una colección de envíos
var envios = new List<Envio>
{
    new Envio { PedidoId = 101, ClienteId = 1, Estado = "Entregado", FechaEntrega = new DateTime(2023, 1, 15) },
    new Envio { PedidoId = 102, ClienteId = 3, Estado = "En tránsito", FechaEntrega = null },
    new Envio { PedidoId = 103, ClienteId = 1, Estado = "Entregado", FechaEntrega = new DateTime(2023, 1, 18) }
};

// Join con múltiples condiciones
var pedidosConEnvios = from p in pedidos
                      join e in envios on new { p.Id, p.ClienteId } equals new { Id = e.PedidoId, ClienteId = e.ClienteId }
                      select new {
                          Producto = p.Producto,
                          Importe = p.Importe,
                          EstadoEnvio = e.Estado,
                          FechaEntrega = e.FechaEntrega
                      };

foreach (var item in pedidosConEnvios)
{
    Console.WriteLine($"Producto: {item.Producto}, Importe: ${item.Importe}");
    Console.WriteLine($"  Estado: {item.EstadoEnvio}");
    Console.WriteLine($"  Entrega: {(item.FechaEntrega.HasValue ? item.FechaEntrega.Value.ToShortDateString() : "Pendiente")}");
}

Join entre más de dos colecciones

Podemos encadenar múltiples operaciones join para combinar datos de tres o más colecciones:

// Añadimos una colección de categorías de productos
var categorias = new List<Categoria>
{
    new Categoria { Id = 1, Nombre = "Electrónica" },
    new Categoria { Id = 2, Nombre = "Periféricos" },
    new Categoria { Id = 3, Nombre = "Oficina" }
};

// Añadimos la categoría a los productos
var productosCategorias = new List<ProductoCategoria>
{
    new ProductoCategoria { Producto = "Laptop", CategoriaId = 1 },
    new ProductoCategoria { Producto = "Monitor", CategoriaId = 1 },
    new ProductoCategoria { Producto = "Teclado", CategoriaId = 2 },
    new ProductoCategoria { Producto = "Mouse", CategoriaId = 2 },
    new ProductoCategoria { Producto = "Impresora", CategoriaId = 3 }
};

// Join de tres colecciones
var informeCompleto = from c in clientes
                     join p in pedidos on c.Id equals p.ClienteId
                     join pc in productosCategorias on p.Producto equals pc.Producto
                     join cat in categorias on pc.CategoriaId equals cat.Id
                     select new {
                         Cliente = c.Nombre,
                         Producto = p.Producto,
                         Categoria = cat.Nombre,
                         Importe = p.Importe
                     };

foreach (var item in informeCompleto)
{
    Console.WriteLine($"Cliente: {item.Cliente}");
    Console.WriteLine($"  Producto: {item.Producto} (Categoría: {item.Categoria})");
    Console.WriteLine($"  Importe: ${item.Importe}");
}

Optimización de consultas Join

Al trabajar con operaciones join, es importante considerar el rendimiento:

• Los joins pueden ser operaciones costosas, especialmente con colecciones grandes.
• Considera materializar colecciones pequeñas que se usan frecuentemente en joins.
• Utiliza índices o estructuras de datos optimizadas cuando sea posible.

// Optimización: convertir una colección pequeña a diccionario para búsquedas más rápidas
var categoriasDict = categorias.ToDictionary(c => c.Id);

// Ahora podemos hacer búsquedas directas sin necesidad de join
var informeOptimizado = from c in clientes
                       join p in pedidos on c.Id equals p.ClienteId
                       join pc in productosCategorias on p.Producto equals pc.Producto
                       let categoria = categoriasDict[pc.CategoriaId]
                       select new {
                           Cliente = c.Nombre,
                           Producto = p.Producto,
                           Categoria = categoria.Nombre,
                           Importe = p.Importe
                       };

Clases utilizadas en los ejemplos

Para completar los ejemplos, aquí están las definiciones de las clases utilizadas:

public class Cliente
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public string Ciudad { get; set; }
}

public class Pedido
{
    public int Id { get; set; }
    public int ClienteId { get; set; }
    public string Producto { get; set; }
    public decimal Importe { get; set; }
}

public class Envio
{
    public int PedidoId { get; set; }
    public int ClienteId { get; set; }
    public string Estado { get; set; }
    public DateTime? FechaEntrega { get; set; }
}

public class Categoria
{
    public int Id { get; set; }
    public string Nombre { get; set; }
}

public class ProductoCategoria
{
    public string Producto { get; set; }
    public int CategoriaId { get; set; }
}

Las operaciones join en LINQ son una herramienta poderosa para trabajar con datos relacionados, permitiéndonos combinar información de múltiples fuentes de manera declarativa y expresiva. Dominar estas operaciones es fundamental para realizar consultas complejas sobre datos distribuidos en diferentes colecciones.