5.2 Formas de cargar información de tablas relacionadas

Entity framework core cuenta con 3 formas para cargar la información de las tablas de llaves foráneas.

Eager loading (carga diligente)

Al obtener un producto, le indicas que también deseas que te incluya los datos de la categoría. Para esto debes incluir un objeto virtual de la tabla categoria en tu tabla producto.

public class Producto
{ 
    [Key] 
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)] 
    public int Id { get; set; }
    
    public virtual Categoria Categoria {get; set; }
            
    [Required(ErrorMessage = "Required")]
    [Range(1,999, ErrorMessage = "Range")]
    public int Clave { get; set; }

    [Required(ErrorMessage = "Required")]
    [Column(TypeName = "VARCHAR(80)")]
    public string Nombre { get; set; }
}

Cuando desees obtener un producto con su categoría, agregas el espacio de nombres System.Data.Entity y con la palabra Include incluyes el nombre de la tabla categoría. De esta manera si luego renombras la tabla categoría utilizando la opción de Visual Studio para renombrar, te cambiara el nombre de la tabla categoría en todas las tablas relacionadas. El query generado es un select de la tabla productos con un join a la tabla categoria.

using System.Data.Entity;
var productos = contexto.Productos.Include(p => p.Categoria).ToList()

Explicit loading (carga explícita)

Aquí indicas que deseas cargar la información de las tablas relacionadas. La diferencia es que con la primera forma se realiza con una sola query con un join y en esta forma se hacen varias consultas a la base de datos. Dependiendo de que tan complejo es la información que necesitas obtener a veces es mejor realizar mas llamadas a la base de datos que una sola query muy compleja.

Por ejemplo deseamos obtener todos los productos de la categoría con el Id 1. Primero obtenemos la categoría con el Id 1. El método Find lo que hace es que busca un registro por medio de su llave primaria, en este caso el Id. El query generado es un select a la tabla categoría donde el id es 1

var categoria = contexto.Categoria.Find(1)

Luego obtenemos todos los productos de esa categoría

contexto.Productos.Where(p=> p.CategoriaId == categoria.Id).ToList()

También de esta manera podemos filtrar la información de los productos por ejemplo que su nombre empiece con A, para esto utilizamos StartWith

var productos = contexto.Producto
                      .Where(p => p.CategoriaId == categoria.Id 
                          && p.Nombre.StartsWith('A')).ToList();

También puedes utilizar el operador in (contains), el cual te permite buscar los productos de diferentes categorías, por ejemplo, quieres encontrar los productos de las categorías cuyo Id es menor a 5. Para esto buscamos las categorías con el Id < 5. Luego mediante la instrucción indicamos que solo deseamos el campo Id de nuestra tabla categoría. Por último filtramos los productos cuya categoría este en la lista anterior.

var categorias = contexto.Categoria.Where(c => c.Id < 5);
var categoriasId = categorias.Select(c => c.Id);
var productos = contexto.Producto.Where
                 (p => categoriasId.Contains(p.CategoriaId)).ToList();

Lazy loading (carga diferida)

De esta manera cargas la información relacionada según la necesites. Para esto es necesario agregar el paquete Microsoft.EntityFrameworkCore.Proxies y habilitarlo en el método OnConfiguring

protected override void OnConfiguring(
         DbContextOptionsBuilder optionsBuilder)
    => optionsBuilder
        .UseLazyLoadingProxies()
        .UseMySql(Configuration.GetConnectionString
                                          ("DefaultConnection"));

Para obtener los productos de la categoría con el Id 1, en nuestra clase Categoria agregamos una objeto que guardará la lista de Productos

public class Categoria 
{ 
    public int Id { get; set; }
        
    public int Clave { get; set; }

    public string Nombre { get; set; }
    
    public virtual ICollection<Producto> Productos { get; set; }
}

Internamente se crea una clase llamada Proxy, la cual sería similar a lo siguiente:

public override Icollection<Producto> Productos
{
    get
    {
      if (_productos == null) 
          _productos = contexto.CargarProductos();
          
      return productos;
    }
}

De esta manera puedes consultar los productos de la categoría con solo acceder a la propiedad Productos de tu objeto Categoria

var categoria = contexto.Categoria.Find(1)
var productos = categoria.Productos;

Aunque parezca que se escribe menos código, la desventaja es que, si tienes muchas tablas relacionadas por ejemplo 5, cuando quieras obtener los datos de tu categoría con sus 5 tablas relacionadas, se realizarían 6 selects, uno para obtener la tabla categoría y otra por cada tabla relacionada que necesites.

Se recomienda mas para aplicaciones de escritorio. Ya que en aplicaciones web o de celulares no muestran tanta información al mismo tiempo y el usuario puede abandonar la página o la app si tarda mucho en cargar.

El link de la documentación oficial de microsoft es https://docs.microsoft.com/es-es/ef/core/querying/related-data

En mi caso prefiero yo indicar cuando quiero cargar la información relacionada por lo cual en la tabla producto solo agregue el campo CategoriaId.

Joins

Inner Join

También puedes obtener la información mediante joins. Agregas la palabra join indicando a que tabla deseas conectarte y con la palabra on primero escribes la primer tabla (categoria) y luego la siguiente tabla. Selecciona los campos que necesitas con select

var categorias_productos = (from categorias in contexto.Categoria
             join productos in contexto.Producto
                on categorias.Id equals productos.CategoriaId
                select new
                {
                    categoria.Id,
                    categoria.Nombre,
                    IdProducto = productos.Id,
                    NombreProducto = productos.Nombre
                }).ToList();

Left Join

Si existieran productos que no tuvieran categoría y deseas mostrar los productos con el nombre de la categoría o una cadena vacía si el producto no tiene categoría se debe realizar un left join. En linq esto se realiza guardando en una variable los datos de la categoría que es la que puede estar vacía y luego seleccionarla con la palabra DefaultIfEmpty

var categoriasYProductos = (from  p in _context.Producto
                               join c in _context.Categoria
                                  on p.CategoriaId equals c.Id
                                  into cat
                                  from categoria in 
                                              cat.DefaultIfEmpty()
                                      select new
                                      {
                                        Categoria = categoria.Nombre,
                                        p.Clave,
                                        p.Nombre
                                      }).ToList();

Agrupar productos por categoría

Group

Puedes agrupar los productos de forma jerárquica de acuerdo al Id de la categoría con la palabra Group. El resultado sería algo así:

Categoría Id: 1
     Producto: Aspirina
     Producto: Paracetamol
Cateogría Id: 2
     Producto: Bicarbonato de sodio

• Selecciona tu tabla productos

• Agrega la palabra group

• Agrega el nombre de tu tabla

• Ordena con la palabra by seguido del campo por el cual deseas agrupar

• Agrega la palabra into seguido de un nombre para el grupo

• Selecciona los campos de tu tabla que deseas mostrar o si seleccionas el nombre del grupo te mostrará todos los campos de tu tabla.

La sintaxis es:

from variable in contexto.NombreTabla group variable by campoGrupo 
       into nombreGrupo select nombreGrupo o campos

Se regresará un objeto el cual tiene:

• Una variable llamada key que contiene el campo por el cual estas agrupando

• Un objeto con los campos seleccionados.

El ejemplo es el siguiente:

var productosXCategoria = from productos in contexto.Producto
            group productos by productos.CategoriaId into p
            select p).ToList()
            
foreach (var categorias in productosXCategoria)
{
    Console.WriteLine("Categoría Id: "  + categorias.Key);
    foreach (var producto in categorias)
    {
        Console.WriteLine("\t Producto: {0}", producto.Nombre);
    }
}

Si deseas mostrar el nombre de la categoría, puedes realizar un group join

Group Join

En este ejemplo mostraré las categorías con el total de productos de cada categoría de la siguiente manera:

Análgesicos: 2
Antiácidos: 1

Realizas el join de categorías con productos, a la tabla productos le indicas que formará un grupo, esto te creará un objeto con los campos de la tabla categoría, y una lista de objetos con los datos de los productos. Con la palabra count() obtenemos el total de productos encontrados

var categoriasProd = (from categorias in _context.Categoria
                      join productos in _context.Producto
                         on categorias.Id equals 
                                        productos.CategoriaId
                             into grupo
                       select new { Categoria = categorias.Nombre,
                                    TotalProductos = grupo.Count()})
                                       .ToList();
foreach (var categoria in categoriasProd )
{
     Console.WriteLine(categoria.Categoria + ": " +
                  categoria.TotalProductos);
}

Si deseas obtener la lista de productos por categoría

Categoría: Análgesicos
     Producto: 1 - Aspirina
     Producto: 2 - Paracetamol
Cateogría: Antiácidos
     Producto: 3 - Bicarbonato de sodio

En lugar del count, simplemente con un select, seleccionamos los campos que necesitamos.

Otra forma de concatenar variables con texto es incluir $ seguido del texto que deseas mostrar y entre llaves pones las variables que deseas mostrar.

var categoriasYProductos = (from c in _context.Categoria
                              join p in _context.Producto
                                 on c.Id equals p.CategoriaId
                                 into grupo
                                   select new
                                   {
                                      Categoria = c.Nombre,
                                      Productos = grupo.Select(g => 
                                          new
                                          {
                                               g.Clave,
                                               g.Nombre
                                           })
                                        }).ToList();
foreach (var categoria in categoriasYProductos)
{
    Console.WriteLine("Categoría: " + categoria.Categoria);
    foreach (var producto in categoria.Productos)
    {
       Console.WriteLine($"Producto: {producto.Clave}
        - { producto.Nombre}");
    }
}

Como último ejemplo de group join, mostraré las categorías con los nombres de los productos separados por coma

Análgesicos: Aspirina, Paracetamol
Antiácidos: Bicabornato de Sodio

Para mostrar los productos separados por , utilizamos el método Join, el primer parámetro es una cadena con la cual deseamos separar los productos, seguido de una lista de productos, para esto seleccionamos el campo nombre del grupo de productos.

var categoriasYProductos = (from c in _context.Categoria
                               join p in _context.Producto
                                    on c.Id equals p.CategoriaId
                                into grupo
                             select new
                             {
                                Categoria = c.Nombre,
                                Productos = string.Join(",", 
                                     grupo.Select(g => g.Nombre))
                             }).ToList();
foreach (var categoria in categoriasYProductos)
{
    Console.WriteLine($"{categoria.Categoria} : 
              {categoria.Productos}");               
}

Aquí puedes ver un pdf con el resumen de las consultas explicadas por si deseas imprimirlo y/o consultarlo para tus proyectos de forma más rápida y offline.

121KB

Resumen LINQ.pdf

pdf