Con este curso he aprendido los conceptos de entity framework y db context, ya que en el curso anterior de ASP .NET CORE, se utilizaron los modelos del curso c# .net core y la explicación muy por encima, y no me había quedado muy claro.
Conocer las bases de .NET core
Desarrollo de Aplicaciones Web con Blazor y Entity Framework
Evolución de las tecnologías .NET
Evolución y Uso de Visual Studio Code en Desarrollo .NET
Desarrollo Web: Cliente, Servidor y Optimización con JavaScript
Instalación de Visual Studio Community paso a paso
Instalación y Configuración de SQL Server Express 2019
Entender la estructura de Blazor
Desarrollo de Aplicaciones con Blazor Server y WebAssembly
Estructura y Configuración de Aplicaciones en Visual Studio Code
Creación de Formularios Dinámicos con Blade y C#
Creación y Uso de Componentes en Glaceau para Formularios Reutilizables
Creación y Gestión de Formularios HTML Básicos
Arquitectura y Patrones de Diseño en Desarrollo de Software
Aplicar Entity Framework
Arquitectura por Capas y Patrones de Diseño en Software
Modelado de Datos para Aplicación de Inventario
Modelo de Datos para Gestión de Inventarios
"Creación de Entidades en .NET Core para Bases de Datos"
Diseño y Configuración de Entidades en Bases de Datos
Construcción de Relaciones en Modelos de Datos con Entity Framework
Creación de Capas de Acceso a Datos con Entity Framework
Configuración y migración de bases de datos con Entity Framework
Precarga de Datos en Bases de Datos con Entity Framework
Integrar datos en ambientes Blazor
Creación de Capas de Negocio en Aplicaciones .NET
CRUD Básico en Bases de Datos Relacionales
"Creación de Formularios para Registro de Productos en Inventario"
"Creación de Formularios y Menús Desplegables en Páginas Web"
Listar y Mostrar Productos en Tabla HTML con C#
Filtrado Dinámico de Productos por Categoría en HTML
Creación y Navegación de Páginas con Listados y Formularios en Sitios Web
Actualización de Información de Productos en Componentes Web
Actualización y Gestión de Formularios en Aplicaciones Web
Integración de Productos en Bodegas: Formularios y Almacenamiento
Asociación de Productos con Bodegas en Sitios Web
Gestión de Entradas y Salidas en Almacenamiento de Bodegas
Cargar y asociar productos a bodegas en Entity Framework
Gestión de Inventarios: Actualización y Control de Stocks
Aplicar Diseño con Bootstrap
Diseño Responsivo con Vustra: Mejora la Experiencia del Usuario
Publicación de Sitios Web en Azure Paso a Paso
Arquitectura y Herramientas para Desarrollo Web
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Crear una base de datos directamente desde el código es un paso esencial para desarrolladores. Ya hemos definido las entidades y sus relaciones; ahora, vamos a repasar cómo se construyen estas relaciones.
En primer lugar, tenemos las categorías y su relación con los productos y el almacenamiento. Las bodegas también se relacionan con el almacenamiento, al igual que las entradas y salidas que sólo se vinculan con esta última parte. Tras este análisis, estamos listos para desarrollar una capa de acceso a datos.
Para construir la capa de acceso a datos, agregaremos un nuevo proyecto a nuestra solución. Este proyecto se nombrará como DataAccess
, construyéndolo como una librería de clases. Dicho proyecto se encargará de manejar la conexión y manipulación de datos utilizando Entity Framework.
public class InventoryContext : DbContext
{
public DbSet<Product> Products { get; set; }
public DbSet<Category> Categories { get; set; }
public DbSet<Warehouse> Warehouses { get; set; }
public DbSet<Storage> Storages { get; set; }
// Agregar demás DbSets según las entidades necesarias
}
Para utilizar Entity Framework, es necesario instalar las librerías correspondientes. Esto se realiza desde el manejador de paquetes NuGet en Visual Studio:
Microsoft.EntityFrameworkCore
y otras librerías necesarias para el manejo de datos.Después de configurar Entity Framework, se procede a definir cómo se llamará cada tabla en la base de datos. Esto se realiza mediante DbSet
en el contexto de datos:
public DbSet<Product> Products { get; set; }
public DbSet<Category> Categories { get; set; }
public DbSet<InputOutput> InputOutputs { get; set; }
public DbSet<Warehouse> Warehouses { get; set; }
public DbSet<Storage> Storages { get; set; }
Es importante realizar las referencias adecuadas entre las capas del proyecto para garantizar la integración correcta de las entidades.
Recomendamos repetir estos procesos hasta familiarizarte con las configuraciones, para solidificar el aprendizaje y el entendimiento del proceso de implementación.
Aportes 14
Preguntas 2
Con este curso he aprendido los conceptos de entity framework y db context, ya que en el curso anterior de ASP .NET CORE, se utilizaron los modelos del curso c# .net core y la explicación muy por encima, y no me había quedado muy claro.
esta explicacion fue lo maximo, ahora si entiendo como es el trabajo con EF DbContext.
Muy buena clase! en el curso de ASP y Net Core vemos muy superficial en Entity Framework y esto me ayudó a comprender mejor como implementarlo.
El **DbContext **es una clase esencial a la hora de utilizar Entity Framework, a través de ella configuramos qué motor de base de datos es el que vamos a utilizar, es con el db context que vamos a poder indicar cuales modelos se van a utilizar para construir nuestra base de datos, y es con esta misma clase que podremos hacer queries hacia nuestra base de datos.
Comparto configuración de ejemplo de InventoryContext con FluentApi (me gusta mucho esta configuración):
public class InventoryContext : DbContext
{
public DbSet<CategoryEntity> Categories { get; set; }
public DbSet<ProductEntity> Products { get; set; }
public DbSet<WarehouseEntity> Warehouses { get; set; }
public DbSet<StorageEntity> Storages { get; set; }
public DbSet<InputOutputEntity> InOuts { get; set; }
public InventoryContext(DbContextOptions<InventoryContext> options) : base(options) { }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<CategoryEntity>(category => {
category.ToTable("Categories");
category.HasKey(p => p.CategoryId);
category.Property(p => p.CategoryName).IsRequired().HasMaxLength(100);
});
modelBuilder.Entity<ProductEntity>(product => {
product.ToTable("Products");
product.HasKey(p => p.ProductId);
product.HasOne(p => p.Category).WithMany(p => p.Products).HasForeignKey(p => p.CategoryId);
product.Property(p => p.ProductName).IsRequired().HasMaxLength(100);
product.Property(p => p.ProductDescription).IsRequired(false).HasMaxLength(600);
product.Property(p => p.TotalQuantity).IsRequired().HasMaxLength(10);
});
modelBuilder.Entity<WarehouseEntity>(warehouse => {
warehouse.ToTable("Warehouses");
warehouse.HasKey(p => p.WarehouseId);
warehouse.Property(p => p.WarehouseName).IsRequired().HasMaxLength(100);
warehouse.Property(p => p.WarehouseAddress).IsRequired().HasMaxLength(300);
});
modelBuilder.Entity<StorageEntity>(storage => {
storage.ToTable("Storages");
storage.HasKey(p => p.StorageId);
storage.HasOne(p => p.Product).WithMany(p => p.Storages).HasForeignKey(p => p.ProductId);
storage.HasOne(p => p.Warehouse).WithMany(p => p.Storages).HasForeignKey(p => p.WarehouseId);
storage.Property(p => p.LastUpdate).IsRequired();
storage.Property(p => p.PartialQuantity).IsRequired();
});
modelBuilder.Entity<InputOutputEntity>(inOut => {
inOut.ToTable("InputsOuputs");
inOut.HasKey(p => p.InOutId);
inOut.HasOne(p => p.Storage).WithMany(p => p.InputOutputs).HasForeignKey(p => p.StorageId);
inOut.Property(p => p.InOutDate).IsRequired();
inOut.Property(p => p.Quantity).IsRequired();
inOut.Property(p => p.IsInput).IsRequired();
});
}
}
Si estan utilizando VSC con el Dotnet CLI, para crear la referencia de paquetes entre un proyecto y otro (nuestras librerias de clases) se usa el siguiente comando
dotnet add Proyecto1/Proyecto1.csproj reference Proyecto2/Proyecto2.csproj
Esto lo ejecutamos desde la carpeta de nuestra solucion que contiene todos nuestro proyectos.
NOTA IMPORTANTE
La referencia se realiza del segundo al primer proyecto
(1 <- 2)
Obviamente las explicaciones más claras y completas son las del curso completo de Entity Framework, pero no se quita el merito que muy bien explicado, porque en el curso de ASP .net si dejó mucho que desear en esta parte.
Para los que tengan un error similar a este:
NU1202: Package Microsoft.EntityFrameworkCore 6.0.3 is not compatible with netcoreapp3.1 (.NETCoreApp,Version=v3.1). Package Microsoft.EntityFrameworkCore 6.0.3 supports: net6.0 (.NETCoreApp,Version=v6.0)
Package restore failed. Rolling back package changes for 'DataAccess'.
Les recomiendo instalar la versión 3.1.1 de Microsoft.EntityFrameworkCore que es el mismo utilizado en el curso.
Me salia este error instalando el paquete de NuGet EntityFramework
(Excepción de HRESULT: 0x80020009 (DISP_E_EXCEPTION))
Lo solucione con los siguientes pasos en el IDE VS2019:
Ingresar al:
-> Tools o Herramientas
-> Import and Export Settings… o Importar o exportar configuraciones
-> Select ‘Reset all settings’ radio button o Restablecer todas las configuraciones
-> Next o Siguiente
-> Select ‘No, just reset settings, overwriting my current settings’ radio button if you want to reset VS to a fresh install settings Español:No, SImplemente restablecer la configuracion reemplazando mi configuracion actual
-> Choose ‘General’ or setting you want to restore to.
-> Finish
Buena clase!
using Inventary.Entities;
using Microsoft.EntityFrameworkCore;
namespace Inventary.DataAccess
{
public class InventaryContext : DbContext
{
public DbSet<ProductEntity> Products { get; set; }
public DbSet<CategoryEntity> Category { get; set; }
public DbSet<InOutEntity> InOut { get; set; }
public DbSet<StorageEntity> Storage { get; set; }
public DbSet<WarehouseEntity> Warehouse { get; set; }
}
}
Excelente
yo si lo habia escrito bien B)
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?