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)

De la misma forma que el anterior tu 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 por 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, 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

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

Siguiendo el mismo ejemplo donde deseas obtener los productos de la categoría con el Id 1, a 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 en este caso categoria y luego la siguiente tabla, con select puedes seleccionar solamente unos campos

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 tuviéramos productos que no tuvieran categoría y quisiéramos 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

Para esto selecciona tu tabla productos, luego la palabra group el nombre de tu tabla, la palabra by seguido del campo por el cual deseas agrupar, luego la palabra into seguido de un nombre para el grupo, por último, seleccionas 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 seria parecida a lo siguiente:

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, seguido de 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 por ejemplo en lugar de mostrar el Id de la categoría 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.