Creando modelo de categoría con Fluent API

Clase 14 de 25 • Curso de Fundamentos de Entity Framework

Marcos Avila Rodriguez

student•

modelBuilder.Entity<projectoef.models.Task>(task => {

            task.ToTable("Task");
            task.HasKey(t => t.TaskId);
            task.Property(t => t.CategoryId);
            task.Property(t => t.Title).IsRequired().HasMaxLength(200);
            task.Property(t => t.Description).HasMaxLength(500);
            task.Property(t => t.PriorityTask).IsRequired();
            task.Property(t => t.CreationDate);
            
        });

Wilson Alexánder Laguna Cárdenas

student•

modelBuilder.Entity<Tarea>(t => {

        t.ToTable("Tarea");
        t.HasKey(t => t.TareaID);
        t.Property(t => t.CategoriaID);
        t.Property(t => t.SubCategoriaID);
        t.Property(t => t.Titulo).IsRequired().HasMaxLength(200);
        t.Property(t => t.Descripcion).HasMaxLength(500);
        t.Property(t => t.PrioridadTarea).IsRequired();
        t.Property(t => t.FechaCreacion);
        
    });

Kevin Castellano

student•

Modelo de Tareas

 modelBuilder.Entity<projectef.Models.Tarea>(tarea=> 
        {
            tarea.ToTable("Tarea");
            tarea.HasKey(p => p.TareaId);
            tarea.HasOne(p => p.Categoria).WithMany(p => p.Tareas).HasForeignKey(p => p.CategoriasId); 
            tareas.Property(p => p.Title).IsRequired().HasMaxLength(200);
            tarea.Property(p => p.Descripcion);
            tarea.Property(p => p.PrioridadTarea);
            tarea.Property(p => p.FechaCreacion);
            tarea.Property(p => p.Categoria);
            tarea.Ignore(p => p.Resumen); 
        });

Jossie Steeven Quintero Giron

student•

Este esta bien.

Platzi Team

student•

Creando modelo de categoría con Fluent API

Para crear nuestro modelo haciendo uso de Fluent API, en nuestro archivo context.cs vamos a agregar la siguiente funcion

protected override void OnModelCreating(ModelBuilder modelBuilder)
	{
		modelBuilder.Entity<Category>(category =>
		{
			category.ToTable("Categoria");
			category.HasKey(c => c.CategoriaId);
			category.Property(c => c.Nombre).HasMaxLength(50).IsRequired();
			category.Property(c => c.Descripcion).HasMaxLength(100).IsRequired();
		});
	}

El método OnModelCreating es un método protegido y sobrecargado que se llama cuando se está creando el modelo de datos en Entity Framework. Este método se utiliza para configurar y personalizar las entidades y las relaciones en el modelo de datos.
- Para asignar el nombre a nuestra table hacemos uso de la propiedad ToTable y le pasamos el nombre de la tabla que queremos en nuestro caso Categoria
- Para especificar nuestra clave principal hacemos uso de la pripiedad HasKey indicandole el cambio que es CategoriaId
- Además, se están especificando las propiedades de la entidad de categoría. El nombre de la propiedad "Nombre" tiene una longitud máxima de 50 caracteres y es un campo requerido. La descripción de la propiedad "Descripción" también tiene una longitud máxima de 100 caracteres y es un campo requerido.

Cesar Augusto Silva Ruiz

student•

Eduardo David Santiago Carrillo

student•

❌ “No se puede usar public override” ✅ En C# sí se puede, pero solo si el método base también es public. Ej: OnModelCreating se sobrescribe con protected override porque en DbContext el método base es protected virtual. No es limitación del lenguaje, es herencia de acceso.

Juan Esteban Lopez Parra

student•

excelente aporte, vengo del curso de POO y la mención del profesor me dejo confundido

Juan Pablo Arano

student•

Por que razon se utiliza Fluent API por encima de la notacion de System.ComponentModel.DataAnnotations? Al parecer System.ComponentModel.DataAnnotations es una manera mas sencilla y rapida de hacer la misma tarea. Gracias por sus respuestas!

Miguel Teheran

teacher•

Fluent API permite agregar mas complejidad y detalle al diseño de cada componente de la base de datos y aparte ayuda a centralizar todo el diseño del esquema de la BD

Franklin Gil

student•

Mas propiedades Doc uno a muchos Doc uno a uno [Doc muchos a muchos] (https://www.entityframeworktutorial.net/efcore/configure-many-to-many-relationship-in-ef-core.aspx)

Maria Emilia Mocayar

student•

Si necesito que el nombre de la propiedad sea distinto al de la columna, cómo lo agrego utilizando Fluent API? Lo había solucionado escribiendo en cada clase 'column' del siguiente modo

[Key]
    [Column("id_usuario")]
    public Guid UsuarioId { get; set; }

Miguel Teheran

teacher•

Usas el método HasColumnName("Id") y le especificas el nombre que llevaria en la BD

Maria Emilia Mocayar

student•

@Mteheran muchas gracías!

Jose Noriega

student•

Reto crear tabla Tarea con Fluent API

using Microsoft.EntityFrameworkCore;

using Models = EntityFrameworkPracticeApp.Models;

internal class TaskDBContext: DbContext {
    public DbSet<EntityFrameworkPracticeApp.Models.Category> Categories {get; set; }
    public DbSet<EntityFrameworkPracticeApp.Models.Task> Tasks { get; set; }

    public TaskDBContext(DbContextOptions<TaskDBContext> options): base(options) {}

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Models.Category>(static model => {
            model.ToTable("category");
            model.HasKey(static p => p.Id);

            model
                .Property(static p => p.Id)
                .HasColumnName("id");

            model
                .Property(static p => p.Name)
                .IsRequired()
                .HasMaxLength(150)
                .HasColumnName("name");

            model
                .Property(static p => p.Description)
                .HasColumnName("description");
        });

        modelBuilder.Entity<Models.Task>(static model => {
            model.ToTable("task");

            model
                .Property(static p => p.Id)
                .HasColumnName("id");

            model
                .Property(static p => p.Name)
                .IsRequired()
                .HasMaxLength(200)
                .HasColumnName("name");

            model
                .Property(static p => p.Description)
                .HasColumnName("description");

            model
                .Property(static p => p.Priority)
                .HasColumnName("priority");

            model
                .Property(static p => p.CategoryId)
                .HasColumnName("category_id");

            model
                .HasOne(static p => p.Category)
                .WithMany(static p => p.Tasks)
                .HasForeignKey(static p => p.CategoryId);

            model
                .Property(static p => p.CreatedAt)
                .HasColumnName("created_at");

            model.Ignore(static p => p.ShortDescription);
        });
    }
}

rafael malanco velazquez

student•

<code> 

modelBuilder.Entity<tarea>(tarea =>
        {
            tarea.ToTable("tarea");                                                     // indica que es una tabla
            tarea.HasKey(t => t.tareaId);                                               // indica que es la clave primaria
            tarea.HasOne(t => t.categoria).WithMany(c => c.tareas).HasForeignKey(t => t.categoriaId); // indica que una tarea tiene una categoria y una categoria tiene muchas tareas
            tarea.Property(t => t.titulo).IsRequired().HasMaxLength(200);               // indica que es un campo obligatorio y su tamaño máximo es 200
            tarea.Property(t => t.descripcion);                                         // indica que es un campo opcional
            tarea.Property(t => t.prioridadTarea).HasConversion(                        // indica que es un campo con una conversión de tipo enumerado
                v => v.ToString(),
                v => (prioridad)Enum.Parse(typeof(prioridad), v));
        });

Ever Enrique castellón Mazariego

student•

modelBuilder.Entity<Tarea>(Tarea =>
        {
            Tarea.ToTable("Tarea");
            Tarea.HasKey(p=> p.TareaId);
            Tarea.HasOne(p=> p.Categoria).WithOne().HasForeignKey<Tarea>(p=> p.CategoriaId);
            Tarea.Property(p=> p.Titulo).IsRequired().HasMaxLength(200);
            Tarea.Property(p=> p.Descripcion);
            Tarea.Property(p=> p.PrioridadTarea);
            Tarea.Property(p=> p.FechaCreacion);
            
        });

Francisco Javier Pineda Giraldo

student•

Hola, tal vez para muchos lo que voy a preguntar es evidente, para mi nivel de programación, NO! es la primera vez que explicas esta clase TareasContext.cs

que a mi manera de entender tiene unas estructuras de datos en una propiedad, para cada una de las tablas.

que significa la linea de codigo: public TareasContext (DbContextOptions<TareasContext> options): base(options) { }

Agradezco sus explicaciones profesor Miguel

Usted se hace entender y tiene buena pedagogía, y los proyectos pueden asimilarse mucho a cosas prácticas que pueden ser replicadas.

Miguel Teheran

teacher•

Hola Francisco:

DbContextOptions<TareasContext> options) es el parámetro que se recibe en el constructor del contexto. Se pueden definir diferentes opciones y configuración sobre EF.

: base(options) Significa que esta trayendo el valor de la clase base de la que estamos heredando (la clase de la que heredamos es DbContext)

Los DbSet son coleciones que presentan un componente en la BD, generalmente puede ser una tabla o una vista

El método OnModelCreating es que sobreescribimos para utilizar FluentAPI y diseñar nuestra BD de manera personalizada

Facundo Oubel

student•

Tengo un problema al tratar de cambiar un NotMaped por un .Ignore

Facundo Oubel

student•

Es para una propiedad que es un static string que si le quito el static me tira error en otra parte del codigo pero si se lo dejo no me deja usar el .ignore

Bryan Oroxón

student•

modelBuilder.Entity<Tarea>(tarea=> { tarea.ToTable("Tarea"); tarea.HasKey(t=> t.TareaId); tarea.Property(t => t.CategoriaId); tarea.Property(t=> t.Titulo).IsRequired().HasMaxLength(200); tarea.Property(p=> p.Descripcion).HasMaxLength(500); tarea.Property(t => t.PrioridadTarea).IsRequired(); tarea.Property(t => t.FechaCreacion); });

Daniel Mauricio Becerra Rincon

student•

con Fluent API tambien se pueden realizar las relaciones que en este caso es de 1aN de la siguiente manera

categoria.HasMany(p => p.Tareas) .WithOne(p => p.Categoria) .HasForeignKey(p => p.CategoriaId) .OnDelete(DeleteBehavior.Cascade);

OnDelete es el comportamiento que se tiene al eliminar datos que se relacionan entre tablas

Cascada (Cascade) → Se eliminan los registros relacionados.

Restricción (Restrict) → No se permite la eliminación si hay registros relacionados.

Valor nulo (SetNull) → Se pone NULL en la clave foránea en vez de eliminar el registro.

Heydi García Sánchez

student•

modelBuilder.Entity<Tarea>(Tarea => { Tarea.ToTable("Tarea"); Tarea.HasKey(c => c.TareaId); Tarea.Property(c => c.CategoriaId).IsRequired(); Tarea.Property(c => c.Titulo).HasMaxLength(200); Tarea.Property(c => c.Descripcion); Tarea.Property(c => c.PrioridadTarea); Tarea.Property(c => c.FechaCreacion); Tarea.Property(c => c.Categoria); Tarea.Ignore(c => c.Resumen); Tarea.HasOne(c => c.Categoria) .WithMany(c => c.Tareas).HasForeignKey(c => c.CategoriaId); });

Heydi García Sánchez

student•

modelBuilder.Entity<Tarea>(Tarea => 
            {
                Tarea.ToTable("Tarea");
                Tarea.HasKey(c => c.TareaId);
                Tarea.Property(c => c.CategoriaId).IsRequired();
                Tarea.Property(c => c.Titulo).HasMaxLength(200);
                Tarea.Property(c => c.Descripcion);
                Tarea.Property(c => c.PrioridadTarea);
                Tarea.Property(c => c.FechaCreacion);
                Tarea.Property(c => c.Categoria);
                Tarea.Ignore(c => c.Resumen);

                Tarea.HasOne(c => c.Categoria)
                .WithMany(c => c.Tareas).HasForeignKey(c => c.CategoriaId);
            });
```modelBuilder.Entity\<Tarea>(Tarea =>             {                Tarea.ToTable("Tarea");                Tarea.HasKey(c => c.TareaId);                Tarea.Property(c => c.CategoriaId).IsRequired();                Tarea.Property(c => c.Titulo).HasMaxLength(200);                Tarea.Property(c => c.Descripcion);                Tarea.Property(c => c.PrioridadTarea);                Tarea.Property(c => c.FechaCreacion);                Tarea.Property(c => c.Categoria);                Tarea.Ignore(c => c.Resumen);
                Tarea.HasOne(c => c.Categoria)                .WithMany(c => c.Tareas).HasForeignKey(c => c.CategoriaId);            });

Federico Mikolajewski

student•

Para mas info de como configurar Fluent

Cristhian Deiby Urbina Herrera

student•

En resumen, en el contexto de la normalización de bases de datos, es común referirse a las tablas en plural, ya que se trata de conjuntos de datos que contienen múltiples instancias de la entidad representada por cada tabla.

Kevin Acuña Quirós

student•

modelBuilder.Entity<Tarea>(tarea => { tarea.ToTable("Tarea"); tarea.HasKey(p => p.TareaId); tarea.HasOne(p => p.Categoria).WithMany(p => p.Tareas).HasForeignKey(p => p.CategoriaId); tarea.Property(p => p.Titulo).IsRequired().HasMaxLength(150); tarea.Property(p => p.Descripcion); tarea.Property(p => p.PrioridadTarea); tarea.Property(p => p.FechaCrecion); tarea.Property(p => p.Categoria); tarea.Ignore(p => p.Resumen); });

modelBuilder.Entity<projectoef.models.Task>(task => {

            task.ToTable("Task");
            task.HasKey(t => t.TaskId);
            task.Property(t => t.CategoryId);
            task.Property(t => t.Title).IsRequired().HasMaxLength(200);
            task.Property(t => t.Description).HasMaxLength(500);
            task.Property(t => t.PriorityTask).IsRequired();
            task.Property(t => t.CreationDate);
            
        });

        t.ToTable("Tarea");
        t.HasKey(t => t.TareaID);
        t.Property(t => t.CategoriaID);
        t.Property(t => t.SubCategoriaID);
        t.Property(t => t.Titulo).IsRequired().HasMaxLength(200);
        t.Property(t => t.Descripcion).HasMaxLength(500);
        t.Property(t => t.PrioridadTarea).IsRequired();
        t.Property(t => t.FechaCreacion);
        
    });

 modelBuilder.Entity<projectef.Models.Tarea>(tarea=> 
        {
            tarea.ToTable("Tarea");
            tarea.HasKey(p => p.TareaId);
            tarea.HasOne(p => p.Categoria).WithMany(p => p.Tareas).HasForeignKey(p => p.CategoriasId); 
            tareas.Property(p => p.Title).IsRequired().HasMaxLength(200);
            tarea.Property(p => p.Descripcion);
            tarea.Property(p => p.PrioridadTarea);
            tarea.Property(p => p.FechaCreacion);
            tarea.Property(p => p.Categoria);
            tarea.Ignore(p => p.Resumen); 
        });

protected override void OnModelCreating(ModelBuilder modelBuilder)
	{
		modelBuilder.Entity<Category>(category =>
		{
			category.ToTable("Categoria");
			category.HasKey(c => c.CategoriaId);
			category.Property(c => c.Nombre).HasMaxLength(50).IsRequired();
			category.Property(c => c.Descripcion).HasMaxLength(100).IsRequired();
		});
	}

using Microsoft.EntityFrameworkCore;

using Models = EntityFrameworkPracticeApp.Models;

internal class TaskDBContext: DbContext {
    public DbSet<EntityFrameworkPracticeApp.Models.Category> Categories {get; set; }
    public DbSet<EntityFrameworkPracticeApp.Models.Task> Tasks { get; set; }

    public TaskDBContext(DbContextOptions<TaskDBContext> options): base(options) {}

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Models.Category>(static model => {
            model.ToTable("category");
            model.HasKey(static p => p.Id);

            model
                .Property(static p => p.Id)
                .HasColumnName("id");

            model
                .Property(static p => p.Name)
                .IsRequired()
                .HasMaxLength(150)
                .HasColumnName("name");

            model
                .Property(static p => p.Description)
                .HasColumnName("description");
        });

        modelBuilder.Entity<Models.Task>(static model => {
            model.ToTable("task");

            model
                .Property(static p => p.Id)
                .HasColumnName("id");

            model
                .Property(static p => p.Name)
                .IsRequired()
                .HasMaxLength(200)
                .HasColumnName("name");

            model
                .Property(static p => p.Description)
                .HasColumnName("description");

            model
                .Property(static p => p.Priority)
                .HasColumnName("priority");

            model
                .Property(static p => p.CategoryId)
                .HasColumnName("category_id");

            model
                .HasOne(static p => p.Category)
                .WithMany(static p => p.Tasks)
                .HasForeignKey(static p => p.CategoryId);

            model
                .Property(static p => p.CreatedAt)
                .HasColumnName("created_at");

            model.Ignore(static p => p.ShortDescription);
        });
    }
}

<code> 

modelBuilder.Entity<tarea>(tarea =>
        {
            tarea.ToTable("tarea");                                                     // indica que es una tabla
            tarea.HasKey(t => t.tareaId);                                               // indica que es la clave primaria
            tarea.HasOne(t => t.categoria).WithMany(c => c.tareas).HasForeignKey(t => t.categoriaId); // indica que una tarea tiene una categoria y una categoria tiene muchas tareas
            tarea.Property(t => t.titulo).IsRequired().HasMaxLength(200);               // indica que es un campo obligatorio y su tamaño máximo es 200
            tarea.Property(t => t.descripcion);                                         // indica que es un campo opcional
            tarea.Property(t => t.prioridadTarea).HasConversion(                        // indica que es un campo con una conversión de tipo enumerado
                v => v.ToString(),
                v => (prioridad)Enum.Parse(typeof(prioridad), v));
        });

modelBuilder.Entity<Tarea>(Tarea =>
        {
            Tarea.ToTable("Tarea");
            Tarea.HasKey(p=> p.TareaId);
            Tarea.HasOne(p=> p.Categoria).WithOne().HasForeignKey<Tarea>(p=> p.CategoriaId);
            Tarea.Property(p=> p.Titulo).IsRequired().HasMaxLength(200);
            Tarea.Property(p=> p.Descripcion);
            Tarea.Property(p=> p.PrioridadTarea);
            Tarea.Property(p=> p.FechaCreacion);
            
        });

modelBuilder.Entity<Tarea>(Tarea => 
            {
                Tarea.ToTable("Tarea");
                Tarea.HasKey(c => c.TareaId);
                Tarea.Property(c => c.CategoriaId).IsRequired();
                Tarea.Property(c => c.Titulo).HasMaxLength(200);
                Tarea.Property(c => c.Descripcion);
                Tarea.Property(c => c.PrioridadTarea);
                Tarea.Property(c => c.FechaCreacion);
                Tarea.Property(c => c.Categoria);
                Tarea.Ignore(c => c.Resumen);

                Tarea.HasOne(c => c.Categoria)
                .WithMany(c => c.Tareas).HasForeignKey(c => c.CategoriaId);
            });
```modelBuilder.Entity\<Tarea>(Tarea =>             {                Tarea.ToTable("Tarea");                Tarea.HasKey(c => c.TareaId);                Tarea.Property(c => c.CategoriaId).IsRequired();                Tarea.Property(c => c.Titulo).HasMaxLength(200);                Tarea.Property(c => c.Descripcion);                Tarea.Property(c => c.PrioridadTarea);                Tarea.Property(c => c.FechaCreacion);                Tarea.Property(c => c.Categoria);                Tarea.Ignore(c => c.Resumen);
                Tarea.HasOne(c => c.Categoria)                .WithMany(c => c.Tareas).HasForeignKey(c => c.CategoriaId);            });

Creando modelo de categoría con Fluent API

Introducción

Bienvenida y presentación

Prerrequisitos

Conexión a base de datos

¿Qué es un ORM en programación?

Introducción a Entity Framework

Creación de proyecto .NET con Entity Framework

Iniciando con Entity Framework

Creación de modelos

Configuración de Entity Framework

Mapeo de modelos usando atributos

Utilizando base de datos en memoria

Conectado a base de datos SQL server

Agregando conexión al archivo appsettings

Utilizando Fluent API

Introducción a Fluent API

Creando modelo de categoría con Fluent API

Creando modelo de tarea con Fluent API

Conectado a base de datos con Fluent API

Migraciones

¿Qué son las migraciones?

Inicializar las migraciones

Creando una migración

Agregando datos semilla

Consumo de datos

Obteniendo datos con Entity Framework

Guardando datos con Entity framework

Actualizando datos con Entity framework

Eliminando datos con Entity framework

Cierre del curso

Continúa tu camino desarrollando