LINQ en ASP.NET MVC: Operaciones Agregadas Sum, Average, Min y Max

En el desarrollo de aplicaciones ASP.NET MVC utilizando Entity Framework, es común realizar consultas que involucren operaciones agregadas para calcular valores resumidos como sumas, promedios, mínimos y máximos de datos en una base de datos. En este artículo, exploraremos cómo utilizar estas operaciones agregadas en consultas LINQ para obtener resultados precisos y eficientes.

Configuración del Proyecto ASP.NET MVC

Para comenzar, configuraremos un proyecto ASP.NET MVC y estableceremos la conexión con una base de datos utilizando Entity Framework Code First. Este enfoque nos permitirá definir nuestras entidades de dominio y generar la estructura de la base de datos a partir de estas definiciones.

Crear un Nuevo Proyecto ASP.NET MVC:

• Abre Visual Studio.
• Selecciona File > New > Project....
• En el panel izquierdo, elige ASP.NET Web Application.
• Asigna un nombre al proyecto y haz clic en Create.
• Selecciona la plantilla ASP.NET MVC y haz clic en Create.

Instalación de Entity Framework:

1. Abre Package Manager Console desde Tools > NuGet Package Manager > Package Manager Console.

2. Ejecuta el siguiente comando para instalar Entity Framework:

Install-Package EntityFramework

 

 

Definición de Entidades y Contexto de Datos

Para trabajar con Entity Framework, primero definimos nuestras entidades y luego configuramos un contexto de datos (DbContext) que actúa como una puerta de entrada para interactuar con la base de datos.

 

Definición de Entidades

Define las clases que representan las entidades principales de tu aplicación (por ejemplo, Customer, Order, Product, OrderDetail).

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Otros campos de cliente
}

public class Order
{
    public int Id { get; set; }
    public DateTime OrderDate { get; set; }
    public decimal TotalAmount { get; set; }
    public int CustomerId { get; set; }
    public Customer Customer { get; set; }
    // Otros campos de pedido
}

// Definir clases restantes: Product, OrderDetail

Configuración del Contexto de Datos (DbContext)

El contexto de datos (DbContext) es una clase que deriva de DbContext y representa una sesión con la base de datos que permite consultar y guardar instancias de entidades.

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext() : base("name=DefaultConnection")
    {
        Database.SetInitializer(new DropCreateDatabaseIfModelChanges<ApplicationDbContext>());
    }

    public DbSet<Customer> Customers { get; set; }
    public DbSet<Order> Orders { get; set; }
    // public DbSet<Product> Products { get; set; }
    // public DbSet<OrderDetail> OrderDetails { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // Configuración adicional del modelo, como restricciones de clave externa, índices, etc.
    }
}

 

• En este ejemplo, ApplicationDbContext es una clase que hereda de DbContext. Define propiedades DbSet para cada una de las entidades (Customers, Orders, Products, OrderDetails), que representan tablas en la base de datos.
• El constructor de ApplicationDbContext especifica la cadena de conexión a la base de datos utilizando base("name=DefaultConnection"). Esta cadena de conexión debe estar definida en el archivo de configuración (web.config o app.config) de tu proyecto.
• Database.SetInitializer se utiliza aquí para establecer la estrategia de inicialización de la base de datos. En este caso, la base de datos se recreará si el modelo cambia.

 

Configuración de la Cadena de Conexión

En el archivo web.config o app.config de tu proyecto, define la cadena de conexión para el contexto de base de datos. Esta cadena de conexión especifica dónde se encuentra la base de datos y cómo acceder a ella.

<connectionStrings>
    <add name="DefaultConnection" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=YourDatabaseName;Integrated Security=True" providerName="System.Data.SqlClient" />
</connectionStrings>

Nota: Asegúrate de reemplazar YourDatabaseName con el nombre de tu base de datos SQL Server.

 

 

Poblar la Base de Datos con Datos de Ejemplo

Para realizar consultas útiles, necesitamos poblar la base de datos con algunos datos de ejemplo. Esto nos permitirá probar nuestras consultas LINQ con operaciones agregadas.

 

Definición del Inicializador de la Base de Datos:

Crea una clase llamada ApplicationDbContextInitializer que derive de DropCreateDatabaseIfModelChanges<ApplicationDbContext> y sobreescribe el método Seed para poblar la base de datos con datos de ejemplo.

public class ApplicationDbContextInitializer : DropCreateDatabaseIfModelChanges<ApplicationDbContext>
{
    protected override void Seed(ApplicationDbContext context)
    {
        var customers = new List<Customer>
        {
            new Customer { Name = "John Doe" },
            new Customer { Name = "Jane Smith" },
            new Customer { Name = "Robert Johnson" }
        };

        var orders = new List<Order>
        {
            new Order { OrderDate = DateTime.Now.AddDays(-10), TotalAmount = 100, Customer = customers[0] },
            new Order { OrderDate = DateTime.Now.AddDays(-5), TotalAmount = 200, Customer = customers[1] },
            new Order { OrderDate = DateTime.Now.AddDays(-1), TotalAmount = 300, Customer = customers[2] },
            new Order { OrderDate = DateTime.Now.AddDays(-20), TotalAmount = 150, Customer = customers[0] },
            new Order { OrderDate = DateTime.Now.AddDays(-15), TotalAmount = 250, Customer = customers[1] },
            new Order { OrderDate = DateTime.Now.AddDays(-30), TotalAmount = 350, Customer = customers[2] },
        };

        context.Customers.AddRange(customers);
        context.Orders.AddRange(orders);
        context.SaveChanges();
    }
}

Nota: En este código, el método Seed se utiliza para poblar la base de datos con datos iniciales. Añadimos una lista de clientes (customers) y una lista de pedidos (orders) y luego las agregamos al contexto y guardamos los cambios.

 

Configuración del Inicializador en el Contexto de Datos

Asegúrate de que el inicializador esté configurado en el constructor de ApplicationDbContext.

public ApplicationDbContext() : base("name=DefaultConnection")
{
    Database.SetInitializer(new ApplicationDbContextInitializer());
}

Nota: Con esta configuración, la base de datos se inicializará y poblará con datos de ejemplo cada vez que el modelo cambie.

 

 

Implementación del Controlador y Vistas

En esta sección, implementaremos un controlador que realizará consultas LINQ con operaciones agregadas para obtener resultados como sumas, promedios, mínimos y máximos.

 

Controlador de Consultas Agregadas

Implementaremos un controlador que realice consultas LINQ con operaciones agregadas y pase los resultados a vistas correspondientes para mostrar los resultados.

public class AggregatedQueriesController : Controller
{
    private ApplicationDbContext _context;

    public AggregatedQueriesController()
    {
        _context = new ApplicationDbContext();
    }

    // GET: AggregatedQueries/TotalSum
    public ActionResult TotalSum()
    {
        decimal totalSum = _context.Orders.Sum(o => o.TotalAmount);
        ViewBag.TotalSum = totalSum;
        return View();
    }

    // GET: AggregatedQueries/AverageAmount
    public ActionResult AverageAmount()
    {
        decimal averageAmount = _context.Orders.Average(o => o.TotalAmount);
        ViewBag.AverageAmount = averageAmount;
        return View();
    }

    // GET: AggregatedQueries/MinAmount
    public ActionResult MinAmount()
    {
        decimal minAmount = _context.Orders.Min(o => o.TotalAmount);
        ViewBag.MinAmount = minAmount;
        return View();
    }

    // GET: AggregatedQueries/MaxAmount
    public ActionResult MaxAmount()
    {
        decimal maxAmount = _context.Orders.Max(o => o.TotalAmount);
        ViewBag.MaxAmount = maxAmount;
        return View();
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            _context.Dispose();
        }
        base.Dispose(disposing);
    }
}

Nota: En este ejemplo, cada acción del controlador realiza una consulta LINQ diferente para calcular una operación agregada y pasa el resultado a la vista a través de ViewBag.

 

Explicación Detallada del Código LINQ

Las operaciones agregadas en LINQ son esenciales para resumir datos. Aquí se detallan las consultas LINQ utilizadas en el controlador:

Sum:

decimal totalSum = _context.Orders.Sum(o => o.TotalAmount);

• Sum calcula la suma total de un campo específico (en este caso, TotalAmount) en una colección.
• En esta consulta, se suma el valor TotalAmount de todos los registros en la tabla Orders.

 

Average:

decimal averageAmount = _context.Orders.Average(o => o.TotalAmount);

• Average calcula el promedio de los valores de un campo específico.
• Aquí, se calcula el promedio de TotalAmount de todos los pedidos.

 

Min:

decimal minAmount = _context.Orders.Min(o => o.TotalAmount);

• Min obtiene el valor mínimo de un campo específico.
• En esta consulta, se encuentra el valor mínimo de TotalAmount entre todos los pedidos.

 

Max:

decimal maxAmount = _context.Orders.Max(o => o.TotalAmount);

• Max obtiene el valor máximo de un campo específico.
• Aquí, se encuentra el valor máximo de TotalAmount entre todos los pedidos.

 

 

Creación de Vistas

Crea vistas correspondientes para cada acción del controlador para mostrar los resultados de las operaciones agregadas.

Vista para TotalSum.cshtml:

@model decimal

<h2>Total Sum of Orders</h2>
<p>Total sum of all order amounts: @ViewBag.TotalSum.ToString("C")</p>

 

Vista para AverageAmount.cshtml:

@model decimal

<h2>Average Amount of Orders</h2>
<p>Average amount of all order amounts: @ViewBag.AverageAmount.ToString("C")</p>

 

Vista para MinAmount.cshtml:

@model decimal

<h2>Minimum Order Amount</h2>
<p>Minimum amount of all order amounts: @ViewBag.MinAmount.ToString("C")</p>

 

Vista para MaxAmount.cshtml:

@model decimal

<h2>Maximum Order Amount</h2>
<p>Maximum amount of all order amounts: @ViewBag.MaxAmount.ToString("C")</p>

 

 

Conclusión

En este artículo, hemos explorado cómo configurar el contexto de datos (DbContext) con Entity Framework en una aplicación ASP.NET MVC para realizar consultas LINQ con operaciones agregadas como Sum, Average, Min y Max. Además, hemos implementado un controlador que realiza estas consultas y muestra los resultados en vistas correspondientes. Esta integración proporciona una forma poderosa y eficiente de calcular estadísticas sobre datos almacenados en una base de datos relacional.