Creación de Capas de Acceso a Datos con Entity Framework

Clase 19 de 38 • Curso de Desarrollo Web con Blazor y .Net Core 3

Resumen

¿Cómo construir una base de datos desde el código?

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.

¿Cómo se agrega un nuevo proyecto para el 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
}

¿Qué necesitamos para trabajar con Entity Framework?

Para utilizar Entity Framework, es necesario instalar las librerías correspondientes. Esto se realiza desde el manejador de paquetes NuGet en Visual Studio:

Hacer clic derecho sobre el proyecto en el explorador de soluciones.
Seleccionar "Administrar paquetes NuGet".
Instalar Microsoft.EntityFrameworkCore y otras librerías necesarias para el manejo de datos.

¿Cómo se definen las tablas en el contexto 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.

¿Qué términos claves destacan en esta implementación?

Entity Framework: Es el framework utilizado para gestionar las operaciones de datos en .NET.
DbContext: Clase base para los contextos de datos en Entity Framework.
DbSet: Representa una tabla en la base de datos.
NuGet: Manejador de paquetes para .NET.
Librerías: Conjunto de funcionalidades externas que se pueden agregar a un proyecto.

Recomendamos repetir estos procesos hasta familiarizarte con las configuraciones, para solidificar el aprendizaje y el entendimiento del proceso de implementación.

Jhonny Andres Ospina Loaiza

student•

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.

Carlos Javier Bazan Huaman

student•

esta explicacion fue lo maximo, ahora si entiendo como es el trabajo con EF DbContext.

Kelvin Omar Silvestre Moises

student•

Estoy de acuerdo bro!

Anahi Zentella Aguirre

company_admin•

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.

Jesús Montero Cuevas

student•

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.

José Javier Vásquez Ramos

student•

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();
            });
        }
    }

Jorge Luis Rangel Benitez

student•

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)

Sergio Martinez Marin

student•

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.

Daniel G. Fernández G.

student•

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.

Jonathan Rodriguez Osorio

student•

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

Rolando Mamani Salas

student•

Buena clase!

Vicente Estrada Domínguez

student•

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; }
    }
}

JAVIER ANTONIO MELO RIVERA

student•

Si uso una librería que aun no tiene using ...., no me genera error, y cuando pongo el using correspondiente me aparecen opacas las palabras, no me aparece en el tono resaltado como en el ejercicio. Que habré hecho mal?

Daniel Meza

student•

Es porque aún no está en uso dentro de tu clase. Sólo la estás digamos "importando" para su uso pero aún no la usas.

Andrés Cueva

student•

excelente explicación profe, hasta da los tips... para q no se olvide el código para los que somos nuevos..

Oscar Jaramillo

student•

Excelente

Oscar Armando Sosa Vasquez

student•

yo si lo habia escrito bien B)

Johan Andrey Chala Sanchez

student•

Al crear un proyecto class library, este tiene como target netcoreapp 3.1 y la solución Inventory tiene target net 5.0. ¿Puede suceder algún tipo de error en la aplicació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();
            });
        }
    }

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'.

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; }
    }
}

Creación de Capas de Acceso a Datos con Entity Framework

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