Conocer las bases de .NET core

1

¿Qué necesitas para aprender a desarrollar aplicaciones profesionales en .NET con Blazor?

2

Todo lo que aprenderás sobre Blazor

3

Evolución de .Net

4

¿Cómo funciona el Desarrollo Web sin Blazor?

5

Instalando Visual Studio Community

6

Instalando SQL Server Express

Entender la estructura de Blazor

7

Webassemblies y .Net Core 3

8

Anatomía de una aplicación Blazor

9

Blazor pages

10

Blazor components

11

Introducción a formularios

12

Inyección de dependencias

Aplicar Entity Framework

13

Arquitectura vs. Patrones de Diseño

14

Estructurando nuestro proyecto

15

¿En qué consiste Entity Framework y por qué vamos a trabajarlo?

16

Creación de entidades

17

Data annotations

18

Trabajando el relacionamiento entre entidades

19

Creando el datacontext

20

Migraciones

21

Alimentando la base de datos

Integrar datos en ambientes Blazor

22

Construyendo la capa intermedia o capa de negocio

23

El CRUD de integración de datos

24

Creación de formularios con Blazor

25

Finalizando el formulario

26

Trabajando listas de datos

27

Agregando filtros a nuestra lista

28

Guardando nuevos registros

29

Creación formulario de actualización de datos

30

Aplicando actualización de datos

31

Registrando productos en almacenamiento

32

Creando página de almacenamiento

33

Cargando productos por Bodega para entradas y salidas

34

Relacionando productos y formulario de entradas y salidas

35

Finalizando el formulario de entradas y salidas

Aplicar Diseño con Bootstrap

36

Revisión de estilos: Introducción a Bootstrap

37

Publicando el sitio

38

Cierre del curso

No tienes acceso a esta clase

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

El CRUD de integración de datos

23/38
Recursos

Aportes 12

Preguntas 3

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Si les sirve, toda la parte del CRUD lo encapsule en una interface, dicha interface la implemente en cada una de las entidades:

 public interface ICRUData<T>
    {

        List<T> ItemList();

        void CreateItem(T item);

        void UpdateItem(T item);

        void DeleteItem(T item);
    }

Al final mis entidades tienen el siguiente aspecto justo al momento de implementar la interface:

public class B_Product : ICRUData<ProductEntity>
    {
        public void CreateItem(ProductEntity item)
        {
            throw new NotImplementedException();
        }

        public void DeleteItem(ProductEntity item)
        {
            throw new NotImplementedException();
        }

        public List<ProductEntity> ItemList()
        {
            throw new NotImplementedException();
        }

        public void UpdateItem(ProductEntity item)
        {
            throw new NotImplementedException();
        }
    }

¿Poner la variable db como atributo de la clase sería la forma correcta de evitar repetir el código o cuál sería la mejor?

public class B_Category
    {
        readonly InventoryContext db = new InventoryContext();
        public List<CategoryEntity> CategoriesList()
        {
            return db.Categories.ToList();
        }

        public void CreateCategory(CategoryEntity oCategory)
        {
            db.Categories.Add(oCategory);
            db.SaveChanges();
        }

        public void UpdateCategory(CategoryEntity oCategory)
        {
            db.Categories.Update(oCategory);
            db.SaveChanges();
        }
    }

Para eliminar podria ser asi:

    public void DeleteCategory(CategoryEntity oCategory)
        {
            using (var db = new InventaryContext())
            {
                db.Categories.Remove(oCategory);
                db.SaveChanges();
            }
        }```

todos los métodos son los mismos en cada clase de la capa de negocio, hay una forma de crear un clase que acepte el tipo de objeto y el parámetro del objeto y solo sea llamarlo por ejemplo en B_Product para que ejecute los métodos y así evitar repetir código?, lo he intentado pero no he podido.

A mi me sirvió este video para entender el using https://www.youtube.com/watch?v=uiQmHQftO9E

Para los que estan utilizando Visual Code

Recuerda que para y dentro de la carpeta Business tienes que ejecutar{
        $ dotnet add package Microsoft.EntityFrameworkCore.Tools
}

En .NET MVC estaba muy acostumbrado a pasar datos de la Vista al Controlador, y en el controlador realizar una llamada a la BD y/o una clase que hiciera la llamada a la BD.

Esta técnica me parece más extensa, mejor elaborada, código más limpio y elegante.

Adjunto el crud mejorado, con el codigo

    public class B_Warehouse
    {
        public List<WarehouseEntity> WarehouseList()
        {
            using (var db = new InventaryContext())
            {
                return db.Warehouses.ToList();
            }
        }
        public void CRUDWarehouse(WarehouseEntity oWarehouse, IOperator op)
        {
            using (var db = new InventaryContext())
            {
                switch (op)
                {
                    case IOperator.Create:
                        db.Warehouses.Add(oWarehouse);
                        db.SaveChanges();
                        break;

                    case IOperator.Update:
                        db.Warehouses.Update(oWarehouse);
                        db.SaveChanges();
                        break;
                }
            }
        }
    }
}```

Realice una clase ENUM para seleccionar el tipo del crud



public enum IOperator
{
     Create,
     Update,
     Delete 
}

Genial

Para el eliminado pueden usar el concepto llamado softdelete.

¿en este proyecto se puede hacer scaffolding para no tener que hacer el crud manualmente?

Reto
Product
![](

Warehouse
![](

Storage
![](

InputOutput
![](