LINQ en ASP.NET MVC: Agrupaciones Jerárquicas y Árboles

En el desarrollo de aplicaciones web con ASP.NET MVC, a menudo necesitamos manejar estructuras de datos jerárquicas y árboles. En este artículo, exploraremos cómo utilizar consultas LINQ para trabajar con estas estructuras de manera eficiente. Veremos cómo configurar el proyecto, definir modelos de datos, poblar la base de datos simulada y, lo más importante, implementar consultas LINQ para manipular datos jerárquicos y de árboles en el controlador.

Configuración del Proyecto ASP.NET MVC

Primero, crearemos un proyecto ASP.NET MVC y configuraremos la conexión con una base de datos utilizando Entity Framework Code First.

Crear un Nuevo Proyecto ASP.NET MVC:

• Abre Visual Studio y selecciona File > New > Project.
• Escoge ASP.NET Web Application (.NET Framework) como el tipo de proyecto.
• Asigna un nombre al proyecto.
• Selecciona la plantilla MVC y haz clic en OK para crear el proyecto.

Instalación de Entity Framework:

• Abre Package Manager Console desde Tools > NuGet Package Manager > Package Manager Console.
• Ejecuta el siguiente comando para instalar Entity Framework:

Install-Package EntityFramework

 

 

Definición de Modelos y Configuración de DbContext

Define los modelos de datos necesarios y configura el DbContext para manejar las relaciones jerárquicas y de árboles:

Category.cs

public class Category
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int? ParentCategoryId { get; set; }
    public virtual Category ParentCategory { get; set; }
    public virtual ICollection<Category> Subcategories { get; set; }
    public virtual ICollection<Product> Products { get; set; }

    public Category()
    {
        Subcategories = new List<Category>();
        Products = new List<Product>();
    }
}

Product.cs

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int CategoryId { get; set; }
    public Category Category { get; set; }
}

 

Configuración del Contexto de Datos (DbContext)

El DbContext es una clase que gestiona las conexiones a la base de datos y permite realizar consultas y guardar datos. En Entity Framework, el DbContext es el puente entre el código y la base de datos. Aquí se define cómo se configuran y gestionan las entidades del modelo de datos.

 

Definición de ApplicationDbContext.cs

public class ApplicationDbContext : DbContext
{
    public DbSet<Category> Categories { get; set; }
    public DbSet<Product> Products { get; set; }

    public ApplicationDbContext() : base("DefaultConnection")
    {
    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // Configuración de la relación de auto-referencia para la entidad Category
        modelBuilder.Entity<Category>()
            .HasOptional(c => c.ParentCategory)
            .WithMany(c => c.Subcategories)
            .HasForeignKey(c => c.ParentCategoryId);

        // Configuración de la relación uno a muchos entre Category y Product
        modelBuilder.Entity<Product>()
            .HasRequired(p => p.Category)
            .WithMany(c => c.Products)
            .HasForeignKey(p => p.CategoryId);
    }
}

• DbSet Properties:

  • public DbSet<Category> Categories { get; set; }
  • public DbSet<Product> Products { get; set; }

  Estas propiedades representan las tablas en la base de datos. DbSet<Category> mapea la entidad Category a una tabla en la base de datos, y DbSet<Product> hace lo mismo para la entidad Product.

• Constructor:

  • public ApplicationDbContext() : base("DefaultConnection")

  Este constructor llama al constructor base de DbContext y pasa el nombre de la cadena de conexión (DefaultConnection). Esto le dice a Entity Framework qué cadena de conexión usar para conectarse a la base de datos.

• OnModelCreating:

  • protected override void OnModelCreating(DbModelBuilder modelBuilder)

  Este método se usa para personalizar la configuración del modelo de datos utilizando el DbModelBuilder. Aquí es donde se definen las relaciones y restricciones entre las entidades.

 

El Método OnModelCreating

El método OnModelCreating permite configurar el modelo de datos más allá de lo que se puede hacer con atributos en las clases de entidad. A continuación se explican las configuraciones realizadas en este método.

1. Relación de Auto-Referencia en Category

modelBuilder.Entity<Category>()
    .HasOptional(c => c.ParentCategory)
    .WithMany(c => c.Subcategories)
    .HasForeignKey(c => c.ParentCategoryId);

• modelBuilder.Entity<Category>(): Esto indica que estamos configurando la entidad Category.

• HasOptional(c => c.ParentCategory): Especifica que la relación entre Category y ParentCategory es opcional. Una categoría puede o no tener una categoría padre.

• WithMany(c => c.Subcategories): Indica que una categoría puede tener muchas subcategorías. Esta configuración establece una relación uno a muchos.

• HasForeignKey(c => c.ParentCategoryId): Especifica que ParentCategoryId es la clave foránea que define la relación entre la categoría y su categoría padre.

 

2. Relación Uno a Muchos entre Category y Product

modelBuilder.Entity<Product>()
    .HasRequired(p => p.Category)
    .WithMany(c => c.Products)
    .HasForeignKey(p => p.CategoryId);

• modelBuilder.Entity<Product>(): Esto indica que estamos configurando la entidad Product.

• HasRequired(p => p.Category): Especifica que la relación entre Product y Category es requerida. Cada producto debe estar asociado con una categoría.

• WithMany(c => c.Products): Indica que una categoría puede tener muchos productos. Esta configuración establece una relación uno a muchos.

• HasForeignKey(p => p.CategoryId): Especifica que CategoryId es la clave foránea que define la relación entre el producto y su categoría.

 

La Cadena de Conexión

La cadena de conexión define cómo la aplicación se conectará a la base de datos. Se encuentra en el archivo Web.config.

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

• name="DefaultConnection": El nombre de la cadena de conexión que se utilizará en el constructor de ApplicationDbContext.

• connectionString="Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=MyDatabase;Integrated Security=True": La cadena de conexión contiene varios elementos:

  • Data Source=(localdb)\MSSQLLocalDB: Especifica el servidor de base de datos.
  • Initial Catalog=MyDatabase: El nombre de la base de datos.
  • Integrated Security=True: Utiliza la seguridad integrada de Windows para la autenticación.

• providerName="System.Data.SqlClient": Especifica el proveedor de la base de datos, en este caso, SQL Server.

 

 

Implementar la Simulación de Base de Datos

Para poblar la base de datos con datos de ejemplo, vamos a utilizar una clase de inicialización de base de datos (ApplicationDbContextInitializer) que hereda de DropCreateDatabaseIfModelChanges. Esto nos permitirá predefinir datos que se insertarán en la base de datos al crearla o cuando cambie el modelo.

Creación de Clase de Inicialización de Base de Datos

Crear una clase de inicialización de la base de datos (ApplicationDbContextInitializer):

using System;
using System.Collections.Generic;
using System.Data.Entity;

public class ApplicationDbContextInitializer : DropCreateDatabaseIfModelChanges<ApplicationDbContext>
{
    protected override void Seed(ApplicationDbContext context)
    {
        // Crear algunas categorías
        var categories = new List<Category>
        {
            new Category
            {
                Name = "Electronics",
                Description = "Devices and gadgets",
                Subcategories = new List<Category>
                {
                    new Category { Name = "Computers" },
                    new Category { Name = "Mobile Phones" },
                    new Category { Name = "Accessories" }
                }
            },
            new Category
            {
                Name = "Clothing",
                Description = "Fashion and apparel",
                Subcategories = new List<Category>
                {
                    new Category { Name = "Men's Clothing" },
                    new Category { Name = "Women's Clothing" },
                    new Category { Name = "Footwear" }
                }
            },
            new Category
            {
                Name = "Books",
                Description = "Literature and learning materials",
                Subcategories = new List<Category>
                {
                    new Category { Name = "Fiction" },
                    new Category { Name = "Non-fiction" },
                    new Category { Name = "Textbooks" }
                }
            },
            new Category
            {
                Name = "Home Appliances",
                Description = "Household items and appliances",
                Subcategories = new List<Category>
                {
                    new Category { Name = "Kitchen Appliances" },
                    new Category { Name = "Cleaning Appliances" }
                }
            },
            new Category
            {
                Name = "Sports Equipment",
                Description = "Gear and accessories for sports",
                Subcategories = new List<Category>
                {
                    new Category { Name = "Team Sports" },
                    new Category { Name = "Individual Sports" }
                }
            }
        };

        // Agregar categorías y subcategorías al contexto
        categories.ForEach(c =>
        {
            context.Categories.Add(c);
            c.Subcategories.ForEach(sc => context.Categories.Add(sc));
        });
        context.SaveChanges();

        // Crear algunos productos asociados a las subcategorías
        var products = new List<Product>
        {
            new Product { Name = "Laptop", Price = 1200, CategoryId = categories[0].Subcategories[0].CategoryId },
            new Product { Name = "Smartphone", Price = 800, CategoryId = categories[0].Subcategories[1].CategoryId },
            new Product { Name = "Tablet", Price = 500, CategoryId = categories[0].Subcategories[2].CategoryId },
            new Product { Name = "Headphones", Price = 150, CategoryId = categories[0].Subcategories[2].CategoryId },
            new Product { Name = "T-shirt", Price = 25, CategoryId = categories[1].Subcategories[0].CategoryId },
            new Product { Name = "Jeans", Price = 50, CategoryId = categories[1].Subcategories[1].CategoryId },
            new Product { Name = "Dress", Price = 80, CategoryId = categories[1].Subcategories[1].CategoryId },
            new Product { Name = "Sweater", Price = 45, CategoryId = categories[1].Subcategories[1].CategoryId },
            new Product { Name = "Programming C#", Price = 40, CategoryId = categories[2].Subcategories[0].CategoryId },
            new Product { Name = "Clean Code", Price = 30, CategoryId = categories[2].Subcategories[1].CategoryId },
            new Product { Name = "Mathematics for Beginners", Price = 20, CategoryId = categories[2].Subcategories[2].CategoryId },
            new Product { Name = "Cooking Basics", Price = 25, CategoryId = categories[2].Subcategories[2].CategoryId },
            new Product { Name = "Refrigerator", Price = 1200, CategoryId = categories[3].Subcategories[0].CategoryId },
            new Product { Name = "Microwave Oven", Price = 300, CategoryId = categories[3].Subcategories[0].CategoryId },
            new Product { Name = "Vacuum Cleaner", Price = 150, CategoryId = categories[3].Subcategories[1].CategoryId },
            new Product { Name = "Blender", Price = 80, CategoryId = categories[3].Subcategories[1].CategoryId },
            new Product { Name = "Football", Price = 40, CategoryId = categories[4].Subcategories[0].CategoryId },
            new Product { Name = "Tennis Racket", Price = 100, CategoryId = categories[4].Subcategories[0].CategoryId },
            new Product { Name = "Basketball", Price = 30, CategoryId = categories[4].Subcategories[0].CategoryId }
        };

        // Agregar productos al contexto
        products.ForEach(p => context.Products.Add(p));
        context.SaveChanges();
    }
}

Explicación:

• Categorías (Category): Cada categoría ahora tiene una lista de subcategorías asociadas. Por ejemplo, la categoría "Electronics" tiene subcategorías como "Computers", "Mobile Phones", y "Accessories".

• Productos (Product): Los productos están ahora asociados directamente a las subcategorías dentro de cada categoría. Por ejemplo, el producto "Laptop" está asociado a la subcategoría "Computers" dentro de la categoría "Electronics".

 

Integración en Global.asax

Para asegurarte de que la inicialización de la base de datos se realice cuando la aplicación se inicie, puedes configurarlo en el archivo Global.asax.cs.

public class MvcApplication : System.Web.HttpApplication
{
    protected void Application_Start()
    {
        // Registrar rutas, filtros, bundles, etc.
        AreaRegistration.RegisterAllAreas();
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);

        // Configurar la inicialización de la base de datos
        Database.SetInitializer(new ApplicationDbContextInitializer());
        using (var context = new ApplicationDbContext())
        {
            context.Database.Initialize(true);
        }
    }
}

Explicación

• Database.SetInitializer: Establece el inicializador de la base de datos como ApplicationDbContextInitializer, asegurando que la base de datos se inicialice con los datos de ejemplo al inicio de la aplicación si cambia el modelo.

• context.Database.Initialize(true): Llama a Initialize(true) para asegurarse de que la base de datos se cree o se actualice con los datos de ejemplo definidos en ApplicationDbContextInitializer.

 

 

Implementación de Consultas LINQ en el Controlador

En este paso, vamos a implementar consultas LINQ en el controlador para manejar datos jerárquicos y de árboles. Nos centraremos en obtener categorías y sus productos asociados, así como en construir un árbol de categorías.

HomeController.cs

public class HomeController : Controller
{
    private ApplicationDbContext _context;

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

    public ActionResult Index()
    {
        // Consulta LINQ para obtener todas las categorías con sus subcategorías y productos asociados
        var categoriesWithProducts = _context.Categories
            .Include(c => c.Subcategories.Select(sc => sc.Products)) // Incluir subcategorías y productos relacionados
            .ToList(); // Convertir a lista para materializar la consulta

        return View(categoriesWithProducts); // Pasar los datos a la vista Index.cshtml
    }

    public ActionResult CategoryTree()
    {
        // Construir un árbol de categorías recursivamente
        var categoriesTree = BuildCategoryTree(_context.Categories.ToList());

        return View(categoriesTree); // Pasar los datos a la vista CategoryTree.cshtml
    }

    // Método para construir un árbol de categorías recursivamente
    private List<Category> BuildCategoryTree(List<Category> categories)
    {
        // Crear un diccionario para mapear categorías por Id para un acceso eficiente
        var categoryMap = categories.ToDictionary(c => c.Id);
        var rootCategories = new List<Category>(); // Lista para almacenar las categorías raíz

        foreach (var category in categories)
        {
            // Verificar si la categoría es raíz (no tiene ParentCategoryId)
            if (category.ParentCategoryId == null)
            {
                rootCategories.Add(category); // Agregar categoría raíz a la lista
            }
            else
            {
                // Obtener la categoría padre utilizando el diccionario
                var parentCategory = categoryMap[(int)category.ParentCategoryId];

                // Verificar si las subcategorías no han sido inicializadas
                if (parentCategory.Subcategories == null)
                {
                    parentCategory.Subcategories = new List<Category>(); // Inicializar subcategorías
                }

                parentCategory.Subcategories.Add(category); // Agregar categoría hija a la lista de subcategorías del padre
            }
        }

        return rootCategories; // Devolver lista de categorías raíz
    }

    // Método Dispose para liberar recursos del contexto de datos
    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            _context.Dispose(); // Liberar contexto de datos
        }
        base.Dispose(disposing); // Llamar al método base Dispose
    }
}

 

 

Explicación detallada del Código LINQ en el Controlador

Consulta LINQ en el método Index():

var categoriesWithProducts = _context.Categories
    .Include(c => c.Subcategories.Select(sc => sc.Products))
    .ToList();

• .Categories: Accede al DbSet Categories en el contexto de datos _context.
• .Include(c => c.Subcategories.Select(sc => sc.Products)): Utiliza Include para cargar las relaciones de navegación Subcategories y Products. Esto asegura que al recuperar Categories, también se cargan sus subcategorías y los productos asociados a cada subcategoría.
• .ToList(): Ejecuta la consulta y materializa los resultados en una lista de Category.

 

Construcción del Árbol de Categorías en CategoryTree():

var categoriesTree = BuildCategoryTree(_context.Categories.ToList());

BuildCategoryTree(_context.Categories.ToList()): Llama al método BuildCategoryTree para construir un árbol de categorías. BuildCategoryTree toma una lista de todas las categorías del contexto de datos _context.Categories y devuelve un árbol de categorías con estructura jerárquica.

 

Método BuildCategoryTree(List<Category> categories):

private List<Category> BuildCategoryTree(List<Category> categories)
{
    var categoryMap = categories.ToDictionary(c => c.Id); // Crea un diccionario de categorías por Id para acceso eficiente
    var rootCategories = new List<Category>(); // Lista para almacenar las categorías raíz

    foreach (var category in categories)
    {
        if (category.ParentCategoryId == null)
        {
            rootCategories.Add(category); // Agrega la categoría a la lista de categorías raíz si no tiene ParentCategoryId
        }
        else
        {
            var parentCategory = categoryMap[(int)category.ParentCategoryId]; // Obtiene la categoría padre desde el diccionario

            if (parentCategory.Subcategories == null)
            {
                parentCategory.Subcategories = new List<Category>(); // Inicializa la lista de subcategorías si es nula
            }

            parentCategory.Subcategories.Add(category); // Agrega la categoría actual como subcategoría del padre
        }
    }

    return rootCategories; // Devuelve la lista de categorías raíz
}

• categoryMap = categories.ToDictionary(c => c.Id): Convierte la lista de categorías en un diccionario donde la clave es el Id de la categoría para un acceso eficiente.
• foreach (var category in categories): Itera sobre cada categoría en la lista de categorías.
• if (category.ParentCategoryId == null): Verifica si la categoría actual no tiene un ParentCategoryId, lo que indica que es una categoría raíz.
• parentCategory = categoryMap[(int)category.ParentCategoryId]: Obtiene la categoría padre utilizando el diccionario categoryMap.
• if (parentCategory.Subcategories == null): Verifica si las subcategorías del padre aún no han sido inicializadas.
• parentCategory.Subcategories.Add(category): Agrega la categoría actual como una subcategoría del padre.

 

Método Dispose(bool disposing):

protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        _context.Dispose(); // Libera los recursos del contexto de datos
    }
    base.Dispose(disposing); // Llama al método Dispose de la clase base
}

• _context.Dispose(): Libera los recursos utilizados por el contexto de datos _context.
• base.Dispose(disposing): Llama al método Dispose de la clase base Controller para liberar otros recursos.

 

 

Creación de Vistas

A continuación, crearemos las vistas Index.cshtml y CategoryTree.cshtml con comentarios detallados sobre cómo se relacionan con los modelos de datos obtenidos mediante consultas LINQ en el controlador.

Index.cshtml:

Esta vista muestra todas las categorías con sus subcategorías y los productos asociados a cada subcategoría.

@model List<Category>

<h2>Categorías y Productos</h2>

@foreach (var category in Model)
{
    <div>
        <h3>@category.Name</h3>
        @if (category.Subcategories.Any())
        {
            <ul>
                @foreach (var subcategory in category.Subcategories)
                {
                    <li>
                        <h4>@subcategory.Name</h4>
                        @if (subcategory.Products.Any())
                        {
                            <ul>
                                @foreach (var product in subcategory.Products)
                                {
                                    <li>@product.Name - $@product.Price</li>
                                }
                            </ul>
                        }
                        else
                        {
                            <p>No hay productos disponibles en esta subcategoría.</p>
                        }
                    </li>
                }
            </ul>
        }
        else
        {
            <p>No hay subcategorías disponibles en esta categoría.</p>
        }
    </div>
}

Explicación:

• @model List<Category>: Define el tipo de modelo que la vista espera recibir desde el controlador. En este caso, una lista de objetos Category.

• @foreach (var category in Model): Itera sobre cada objeto Category en la lista Model que recibió desde el controlador.

• <h3>@category.Name</h3>: Muestra el nombre de la categoría actual en un encabezado de nivel 3 (<h3>).

• @if (category.Subcategories.Any()): Verifica si la categoría tiene subcategorías.

  • <ul>...</ul>: Si hay subcategorías, crea una lista desordenada para mostrarlas.

    • @foreach (var subcategory in category.Subcategories): Itera sobre cada subcategoría de la categoría actual.

      • <li>...</li>: Para cada subcategoría, crea un elemento de lista (<li>).

        • <h4>@subcategory.Name</h4>: Muestra el nombre de la subcategoría en un encabezado de nivel 4 (<h4>).

        • @if (subcategory.Products.Any()): Verifica si la subcategoría tiene productos asociados.

          • <ul>...</ul>: Si hay productos, crea una lista desordenada para mostrarlos.

            • @foreach (var product in subcategory.Products): Itera sobre cada producto de la subcategoría.

              • <li>@product.Name - $@product.Price</li>: Muestra el nombre y el precio del producto en un elemento de lista (<li>).

          • else: Si no hay productos en la subcategoría, muestra un mensaje indicando que no hay productos disponibles.

      • else: Si no hay subcategorías para la categoría actual, muestra un mensaje indicando que no hay subcategorías disponibles.

 

CategoryTree.cshtml:

Esta vista muestra un árbol jerárquico de categorías y subcategorías.

@model List<Category>

<h2>Árbol de Categorías</h2>

<ul>
    @foreach (var category in Model)
    {
        <li>
            @Html.DisplayFor(model => category.Name)
            @if (category.Subcategories.Any())
            {
                <ul>
                    @foreach (var subcategory in category.Subcategories)
                    {
                        <li>
                            @Html.DisplayFor(model => subcategory.Name)
                            @if (subcategory.Products.Any())
                            {
                                <ul>
                                    @foreach (var product in subcategory.Products)
                                    {
                                        <li>@Html.DisplayFor(model => product.Name) - $@Html.DisplayFor(model => product.Price)</li>
                                    }
                                </ul>
                            }
                            else
                            {
                                <p>No hay productos disponibles en esta subcategoría.</p>
                            }
                        </li>
                    }
                </ul>
            }
            else
            {
                <p>No hay subcategorías disponibles en esta categoría.</p>
            }
        </li>
    }
</ul>

Explicación:

• @model List<Category>: Define el tipo de modelo que la vista espera recibir desde el controlador.

• @foreach (var category in Model): Itera sobre cada objeto Category en la lista Model que recibió desde el controlador.

• <li>@Html.DisplayFor(model => category.Name): Muestra el nombre de la categoría actual utilizando Html.DisplayFor, que permite personalizar la forma en que se muestra el nombre de la categoría.

• @if (category.Subcategories.Any()): Verifica si la categoría tiene subcategorías.

  • <ul>...</ul>: Si hay subcategorías, crea una lista desordenada para mostrarlas.

    • @foreach (var subcategory in category.Subcategories): Itera sobre cada subcategoría de la categoría actual.

      • <li>...</li>: Para cada subcategoría, crea un elemento de lista (<li>).

        • @Html.DisplayFor(model => subcategory.Name): Muestra el nombre de la subcategoría utilizando Html.DisplayFor.

        • @if (subcategory.Products.Any()): Verifica si la subcategoría tiene productos asociados.

          • <ul>...</ul>: Si hay productos, crea una lista desordenada para mostrarlos.

            • @foreach (var product in subcategory.Products): Itera sobre cada producto de la subcategoría.

              • <li>@Html.DisplayFor(model => product.Name) - $@Html.DisplayFor(model => product.Price)</li>: Muestra el nombre y el precio del producto utilizando Html.DisplayFor.

          • else: Si no hay productos en la subcategoría, muestra un mensaje indicando que no hay productos disponibles.

      • else: Si no hay subcategorías para la categoría actual, muestra un mensaje indicando que no hay subcategorías disponibles.

 

 

Conclusión

El uso de consultas LINQ con estructuras jerárquicas y árboles en ASP.NET MVC proporciona una base sólida para la gestión efectiva de datos complejos y la presentación dinámica en aplicaciones web. Espero que este artículo sirva como una guía práctica y exhaustiva para desarrolladores que buscan maximizar el potencial de LINQ en la manipulación y visualización de datos jerárquicos en sus proyectos ASP.NET MVC.