Creando modelo de categoría con Fluent API
Contenido del curso
Iniciando con Entity Framework
Utilizando Fluent API
Migraciones
Consumo de datos
Cierre del curso
Creando modelo de categoría con Fluent API
Todos los cursos GRATIS
Se acaba en:
:::
Contenido del curso
Creando modelo de categoría con Fluent API
Marcos Avila Rodriguez
Estudiante
Wilson Alexánder Laguna Cárdenas
Estudiante
Kevin Castellano
Estudiante
Jossie Steeven Quintero Giron
Estudiante
Platzi Team
Estudiante
Cesar Augusto Silva Ruiz
Estudiante
Eduardo David Santiago Carrillo
Estudiante
Juan Esteban Lopez Parra
Estudiante
Juan Pablo Arano
Estudiante
Miguel Teheran
Profesor
Franklin Gil
Estudiante
Daniel Mauricio Becerra Rincon
Estudiante
Maria Emilia Mocayar
EstudianteMiguel Teheran
ProfesorMaria Emilia Mocayar
Estudiante
Jose Noriega
Estudiante
rafael malanco velazquez
Estudiante
Ever Enrique castellón Mazariego
Estudiante
Francisco Javier Pineda Giraldo
EstudianteMiguel Teheran
Profesor
Facundo Oubel
EstudianteFacundo Oubel
Estudiante
Bryan Oroxón
Estudiante
Heydi García Sánchez
EstudianteHeydi García Sánchez
Estudiante
Federico Mikolajewski
Estudiante
Cristhian Deiby Urbina Herrera
Estudiante
Kevin Acuña Quirós
EstudiantemodelBuilder.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); });
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); });
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); });
Este esta bien.
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(); }); }
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.
ToTable y le pasamos el nombre de la tabla que queremos en nuestro caso CategoriaHasKey indicandole el cambio que es CategoriaIdNombre" 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.
❌ “No se puede usar
public override” ✅ En C# sí se puede, pero solo si el método base también espublic. Ej:OnModelCreatingse sobrescribe conprotected overrideporque enDbContextel método base esprotected virtual. No es limitación del lenguaje, es herencia de acceso.
excelente aporte, vengo del curso de POO y la mención del profesor me dejo confundido
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!
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
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)
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.
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; }
Usas el método HasColumnName("Id") y le especificas el nombre que llevaria en la BD
@Mteheran muchas gracías!
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); }); } }
<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); });
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.
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
Tengo un problema al tratar de cambiar un NotMaped por un .Ignore
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
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); });
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); }); ```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); });
Para mas info de como configurar Fluent
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.
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); });