Creando los modelos

Hola de nuevo, continuamos con este mini curso de EntityFrameWorkCore, por si aun no has leído las entradas anteriores te las dejo para que te pongas al día:

• Parte I: https://asociacionaepi.es/curso-de-entityframeworkcore-parte-1-instalando-herramientas/
• Parte II: https://asociacionaepi.es/curso-de-entityframeworkcore-parte-ii-el-dbcontext/

Llegados a este punto ya tenemos preparada la pieza central de EntityFrameWorkCore; la clase ApplicationDbContext, ahora es turno de crear los modelos, es decir, la clases de C# que van a representar a las tablas de mi base de datos de cursos. En concreto vamos a crear las siguientes clases:

• Comentario
• Curso
• CursoInstructor
• Instructor
• Precio

Para ello hacemos clic derecho sobre nuestro proyecto Agregar -> Clase y vamos creando las clases mencionadas anteriormente, respetando el mismo nombre que hemos indicado. Ahora toca escribir el código de cada clase, te lo dejo a continuación:

CLASE COMENTARIO

public class Comentario
{
  public int ComentarioId {get;set;}
  public string Alumno {get;set;}
  public int Puntuaje {get;set;}
  public string ComentarioTexto {get;set;}
  
  public int CursoId{get;set;}
  public Curso Curso {get;set;}
}

En esta clase Comentario, creamos primero un campo ComentarioId, este campo lo tomará EntityFrameWorkCore automáticamente para establecer la clave primaria en la tabla Comentario que va a crear posteriormente. Los campos Alumno, Puntuaje y ComentarioTexto son campos normales para guardar información. Sin embargo después tenemos dos campos mas, ComentarioId y Curso, estos campos se usan de esta manera para establecer una relación OneToOne con la tabla Curso, es decir, un Comentario va a pertenecer a un Curso y viceversa.

CLASE CURSO

public class Curso
{
  public int CursoId { get; set; }
  public string Titulo { get; set; }
  public string Descripcion { get; set; }
  public DateTime FechaPublicacion { get; set; }
  
  public Precio Precio { get; set; }
  public ICollection<Comentario> ListaComentarios { get; set; }
  public ICollection<CursoInstructor> InstructorLink { get; set; }
}

En esta clase Curso, creamos primero un campo CursoId, este campo lo tomará EntityFrameWorkCore automáticamente para establecer la clave primaria en la tabla Curso que va a crear posteriormente. Los campos Titulo, Descripcion y FechaPublicacion son campos normales para guardar información. Sin embargo después tenemos tres campos mas, Precio, ListaComentarios y InstructorLink.

El campo Precio se usa de esta manera para establecer una relación OneToOne con la tabla Curso, es decir, un Curso va a tener un Precio y viceversa.

El campo ListaComentarios se usa de esta manera para establecer una relación OneToMany (uno a muchos), es decir un Curso puede tener muchos Comentarios y eso se representa a nivel de código creando una estructura de datos de tipo ICollection.

El campo InstructorLink se usa de esta manera para establecer una relación ManyToMany (muchos a muchos), es decir muchos Cursos pueden tener muchos Instructores y muchos Instructores pueden tener muchos Cursos y eso se representa a nivel de código creando una estructura de datos de tipo ICollection. Para el tipo de relación ManyToMany debemos crear una tabla intermedia, en este caso denominada CursoInstructor, la cual explicamos a continuación.

CLASE CURSOINSTRUCTOR

public class CursoInstructor
{
  public int InstructorId {get;set;}
  public int CursoId {get;set;}
  
  public Curso Curso {get;set;}
  public Instructor Instructor {get;set;}
}

En esta clase CursoInstructor, creamos primero dos campos InstructorId y CursoId, estos campos los tomará EntityFrameWorkCore automáticamente para establecer las claves primarias en la tabla CursoInstructor que va a crear posteriormente mediante la migración. Los campos Curso e Instructor no se crearán en la base de datos, estos campos serán usados a nivel de proyecto de C# para poder acceder a la información de dichas tablas relacionadas.

CLASE INSTRUCTOR

public class Instructor
{
  public int InstructorId {get;set;}
  public string Nombre{get;set;}
  public string Apellidos {get;set;}
  public string Grado {get;set;}
  public byte[] FotoPerfil{get;set;}

  public ICollection<CursoInstructor> CursoLink {get;set;}
}

En esta clase Instructor, creamos primero un campo InstructorId, este campo lo tomará EntityFrameWorkCore automáticamente para establecer la clave primaria en la tabla Instructor que va a crear posteriormente. Los campos Nombre, Apellidos, Grado y FotoPerfil son campos normales para guardar información. Sin embargo después tenemos un campo mas CursoLink, el campo CursoLink se usa de esta manera para establecer una relación ManyToMany (muchos a muchos), es decir muchos Cursos pueden tener muchos Instructores y muchos Instructores pueden tener muchos Cursos y eso se representa a nivel de código creando una estructura de datos de tipo ICollection.

CLASE PRECIO

public class Precio
{
  public int PrecioId { get; set; }
  public decimal PrecioActual { get; set; }
  public decimal Promocion { get; set; }
  
  public int CursoId { get; set; }
  public Curso Curso { get; set; }
}

En esta clase Precio, creamos primero un campo PrecioId, este campo lo tomará EntityFrameWorkCore automáticamente para establecer la clave primaria en la tabla Precio que va a crear posteriormente. Los campos PrecioActual y Promocion son campos normales para guardar información. Sin embargo después tenemos dos campos mas, CursoId y Curso, estos campos se usan de esta manera para establecer una relación OneToOne con la tabla Curso, es decir, un Precio va a pertenecer a un Curso y viceversa.

Ahora toca el turno de modificar la clase ApplicationDbContext para que EntityFrameWorkCore sepa que tablas debe crear en la base de datos, quedando la clase de esta manera:

public class ApplicationDbContext : DbContext
{
  private const string ConnectionString = @"Data Source=MiServidor_SQLSERVER;Initial Catalog=cursos;Trusted_Connection=True;";

  protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  {
    base.OnConfiguring(optionsBuilder);
    optionsBuilder.UseSqlServer(ConnectionString);
  }

  protected override void OnModelCreating(ModelBuilder modelBuilder)
  {
    // Es obligatorio especificar que la tabla intermedia tiene una clave
    // primaria compuesta
    modelBuilder.Entity<CursoInstructor>().HasKey(ci => new { ci.CursoId, ci.InstructorId });
  }

  public DbSet<Curso> Curso { get; set; }
  public DbSet<Precio> Precio { get; set; }
  public DbSet<Comentario> Comentario { get; set; }
  public DbSet<Instructor> Instructor { get; set; }
  public DbSet<CursoInstructor> CursoInstructor { get; set; }

}

Como podemos observar gracias a DbSet podemos indicar a EntityFrameWorkCore qué tablas debe migrar a la base de datos, otro punto muy importante es el método OnModelCreating, este método lo usamos para indicar mediante la API Fluente que nuestra tabla CursoInstructor esta compuesta por dos claves primarias: CursoId e InstructorId.

Ya tenemos todas la clases modelo de nuestro proyecto, es hora de establecer las migraciones, para que estas clases de C# pasen a ser tablas en la base de datos cursos, para ello si estamos usando Visual Studio, debemos abrir la Consola del Administrados de paquetes, para ello pulsamos sobre el menú Herramientas -> Administrador de paquetes Nuget -> Consola del Administrados de paquetes y en la terminal que se abre escribiremos estos dos comandos y en este orden:

• Add-Migration Initial // Este comando crea una migración llamada Initial, podemos poner el nombre que queramos
• Update-Database // Este comando actualiza la base de datos

Al terminar las migraciones ya tendremos en nuestro SQL Server creada la base de datos «cursos» y nuestras tablas.

En la próxima entrega de este mini curso empezaremos a trabajar con los datos, creando un CRUD para leer, insertar, eliminar y actualizar datos de nuestra base de datos.

Si te ha gustado comparte por favor, nos ayudas mucho!

Jesús Jiménez