# 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. ```csharp 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. ```csharp 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 ```csharp var categoria = contexto.Categoria.Find(1) ``` Luego obtenemos todos los productos de esa categoría ```csharp 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 ```csharp 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. ```csharp 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](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Proxies/) y habilitarlo en el método OnConfiguring ```csharp 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 ```csharp public class Categoria { public int Id { get; set; } public int Clave { get; set; } public string Nombre { get; set; } public virtual ICollection Productos { get; set; } } ``` Internamente se crea una clase llamada Proxy, la cual sería similar a lo siguiente: ```csharp public override Icollection 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 ```csharp 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. {% hint style="info" %} 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. {% endhint %} El link de la documentación oficial de microsoft es 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** ```csharp 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** ```csharp 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: ```csharp 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: ```csharp 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 ```csharp 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. ```csharp 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. ```csharp 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. {% file src="/files/-LSrfBh1S7c3rk4SgJWe" %} --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://abi.gitbook.io/net-core/5.-agregando-el-servicio-para-los-productos/5.2-crear-las-llaves-foraneas-e-indices.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.