Conocer las bases de .NET core

1

Desarrollo de Aplicaciones Web con Blazor y Entity Framework

2

Evolución de las tecnologías .NET

3

Evolución y Uso de Visual Studio Code en Desarrollo .NET

4

Desarrollo Web: Cliente, Servidor y Optimización con JavaScript

5

Instalación de Visual Studio Community paso a paso

6

Instalación y Configuración de SQL Server Express 2019

Entender la estructura de Blazor

7

Desarrollo de Aplicaciones con Blazor Server y WebAssembly

8

Estructura y Configuración de Aplicaciones en Visual Studio Code

9

Creación de Formularios Dinámicos con Blade y C#

10

Creación y Uso de Componentes en Glaceau para Formularios Reutilizables

11

Creación y Gestión de Formularios HTML Básicos

12

Arquitectura y Patrones de Diseño en Desarrollo de Software

Aplicar Entity Framework

13

Arquitectura por Capas y Patrones de Diseño en Software

14

Modelado de Datos para Aplicación de Inventario

15

Modelo de Datos para Gestión de Inventarios

16

"Creación de Entidades en .NET Core para Bases de Datos"

17

Diseño y Configuración de Entidades en Bases de Datos

18

Construcción de Relaciones en Modelos de Datos con Entity Framework

19

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

20

Configuración y migración de bases de datos con Entity Framework

21

Precarga de Datos en Bases de Datos con Entity Framework

Integrar datos en ambientes Blazor

22

Creación de Capas de Negocio en Aplicaciones .NET

23

CRUD Básico en Bases de Datos Relacionales

24

"Creación de Formularios para Registro de Productos en Inventario"

25

"Creación de Formularios y Menús Desplegables en Páginas Web"

26

Listar y Mostrar Productos en Tabla HTML con C#

27

Filtrado Dinámico de Productos por Categoría en HTML

28

Creación y Navegación de Páginas con Listados y Formularios en Sitios Web

29

Actualización de Información de Productos en Componentes Web

30

Actualización y Gestión de Formularios en Aplicaciones Web

31

Integración de Productos en Bodegas: Formularios y Almacenamiento

32

Asociación de Productos con Bodegas en Sitios Web

33

Gestión de Entradas y Salidas en Almacenamiento de Bodegas

34

Cargar y asociar productos a bodegas en Entity Framework

35

Gestión de Inventarios: Actualización y Control de Stocks

Aplicar Diseño con Bootstrap

36

Diseño Responsivo con Vustra: Mejora la Experiencia del Usuario

37

Publicación de Sitios Web en Azure Paso a Paso

38

Arquitectura y Herramientas para Desarrollo Web

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

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

19/38
Recursos

¿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:

  1. Hacer clic derecho sobre el proyecto en el explorador de soluciones.
  2. Seleccionar "Administrar paquetes NuGet".
  3. 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.

Aportes 14

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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 explicación profe, hasta da los tips... para q no se olvide el código para los que somos nuevos..

Excelente

yo si lo habia escrito bien B)