Haciendo fácil el acceso a datos con Entity Framework Core (Parte 2)

Entity Framework Core

Venimos con la segunda parte de “Haciendo fácil el acceso a datos con Entity Framework Core“. Esta vez, vamos a hacer el mismo ejemplo, pero con la opción “Code First”. Utilizando esta opción, vamos a generar nuestra base de datos mediante clases que relacionaremos entre ellas, así veremos las dos caras de la moneda.

Modelo

Tengamos el objetivo claro, mediante la opción “Code First” vamos a buscar conseguir un modelo como este:
Modelo DB

En el tenemos 2 relaciones 1 a muchos:

  1. Un profesor podrá impartir varios cursos.
  2. Cada curso puede tener varios alumnos.

Creando la solución en Visual Studio

En primer lugar, vamos a crear el proyecto, solo que esta vez, será un proyecto de consola Net Core:

consola .net core

Paquetes

Como la vez anterior, instalamos los paquetes de Entity Framework Core vía NuGet:

efctools

En caso de querer hacerlo vía consola:

PM->Install-Package Microsoft.EntityFrameworkCore -Version 2.1.3
PM->Install-Package Microsoft.EntityFrameworkCore.Tools -Version 2.1.3

Y lo mismo para el proveedor de MySql

pomelo

O como siempre, por consola:

PM->Install-Package Pomelo.EntityFrameworkCore.MySql -Version 2.1.2

Creando la solución en DotNet CLI

Una de las ventajas de Net Core es que nos permite ejecutar sus acciones desde línea de comandos, con eso, conseguimos toda la funcionalidad en plataformas como Linux. En este caso, utilizaremos la Powershell. Para crear un proyecto, crearemos una carpeta y navegaremos a ella con:

– mkdir PostEntityCore
– cd PostEntityCore

Una vez dentro de la carpeta, crearemos el proyecto y añadiremos los paquetes con:

– dotnet new console
– dotnet add package Microsoft.EntityFrameworkCore -v 2.1.3
– dotnet add package Microsoft.EntityFrameworkCore.Tools -v 2.1.3
– dotnet add package Pomelo.EntityFrameworkCore.MySql -v 2.1.2

Generando el DbContext

En este caso, el modelo lo vamos a generar mediante clases en nuestro proyecto, a fin de organizar el proyecto, añadiremos una carpeta “Data” a la solución, donde añadiremos las siguientes clases:

Entity Framework Core

Vamos a desgranar las clases:

Entity Framework Core “Code First” en Visual Studio

Una vez tenemos el contexto creado en nuestro proyecto, iremos a la “Consola del Administrador de paquetes”, y ahí dispondremos de estos comandos:

  1. add-migration {nombre} -Context {contexto}
  2. remove-migration
  3. update-database {nombre} -Context {contexto}
  4. drop-database -Context {contexto}

Vamos a explicar los comandos:

add-migration: Con este comando, generaremos la migración que lanzaremos a la base de datos. Este comando tiene 2 parámetros:

  1. {nombre}: Con este parámetro indicaremos el nombre que queremos indicarle a la migración, ademas, es obligatorio.
  2. -Context {contexto}: En caso de tener más de un contexto de datos en nuestro programa, indicaremos cual de los contextos es mediante este parámetro. Si solo tenemos un contexto de datos, no es obligatorio usarlo.

remove-migration: Con este comando, eliminaremos la ultima migración que hemos generado. Se puede utilizar varias veces consecutivamente para ir eliminando migraciones desde la última a la primera.

update-database: Con este comando, enviaremos a la base de datos los cambios de la migración, haciéndola efectiva:

  1. {nombre}: Con este parámetro indicaremos el nombre de la migración que queremos aplicar.
  2. -Context {contexto}: En caso de tener más de un contexto de datos en nuestro programa, indicaremos cual de los contextos es mediante este parámetro. Si solo tenemos un contexto de datos, no es obligatorio usarlo.

drop-database: Con este comando, eliminaremos la base de datos. Este comando tiene 1 parámetro:

  1. -Context {contexto}: En caso de tener más de un contexto de datos en nuestro programa, indicaremos cual de los contextos es mediante este parámetro. Si solo tenemos un contexto de datos, no es obligatorio usarlo.

Una vez que conocemos los comandos, vamos a ponernos en faena… Para empezar, utilizamos el comando:

add-migration init -Context PostDbContext

Esto genera una carpeta “Migrations” donde va a ir guardando cada una de las migraciones. Conviene no borrar el contenido, ya que almacena las “versiones” del contexto de datos, de modo que podemos revertir los cambios en la base de datos. Ademas, el hecho de almacenar estas migraciones, permite al sistema aplicar cambios de manera incremental en las próximas migraciones, y es requisito para poder aplicar cambios a la base de datos sin que se produzcan errores por tablas ya existentes.

Con eso, ejecutamos:

update-database -Context PostDbContext

Entity Framework Core “Code First” en DotNet CLI

Igualmente, podemos hacer toda la labor desde el cli de dotnet con los comandos equivalentes de “dotnet ef”:

  1. migrations add {nombre} -c {contexto}
  2. migrations remove
  3. database update {nombre} -c {contexto}
  4. database  drop -c {contexto}

Vamos a explicar los comandos:

migrations add: Con este comando, generaremos la migración que lanzaremos a la base de datos. Este comando tiene 2 parámetros:

  1. {nombre}: Con este parámetro indicaremos el nombre que queremos indicarle a la migración, ademas, es obligatorio.
  2. -c {contexto}: En caso de tener más de un contexto de datos en nuestro programa, indicaremos cual de los contextos es mediante este parámetro. Si solo tenemos un contexto de datos, no es obligatorio usarlo.

migrations remove: Con este comando, eliminaremos la ultima migración que hemos generado. Se puede utilizar varias veces consecutivamente para ir eliminando migraciones desde la última a la primera.

database update: Con este comando, enviaremos a la base de datos los cambios de la migración, haciéndola efectiva:

  1. {nombre}: Con este parámetro indicaremos el nombre de la migración que queremos aplicar.
  2. -c {contexto}: En caso de tener más de un contexto de datos en nuestro programa, indicaremos cual de los contextos es mediante este parámetro. Si solo tenemos un contexto de datos, no es obligatorio usarlo.

database drop: Con este comando, eliminaremos la base de datos. Este comando tiene 1 parámetro:

  1. -c {contexto}: En caso de tener más de un contexto de datos en nuestro programa, indicaremos cual de los contextos es mediante este parámetro. Si solo tenemos un contexto de datos, no es obligatorio usarlo.

Una vez que conocemos los comandos del CLI, vamos a ello

dotnet ef migrations add init -c PostDbContext

En este caso, debemos tener las mismas cosas en consideración que si lo hiciésemos desde Visual Studio.

Con eso, ejecutamos:

dotnet ef database update -c PostDbContext

Resultado

Una vez hecho esto de cualquiera de las 2 maneras, desde el gestor de nuestra base de datos, veremos que se ha creado la base de datos, y si aplicamos la ingeniería inversa para reconstruir el modelo (desde el MySql Workbench), veremos algo así:Entity Framework Core:

Vemos que hemos conseguido generar el modelo que queríamos, pero tenemos una tabla más, “__efmigrationshistory”, en esta tabla es donde Entity Framework Core registra las versiones del contexto que están aplicadas en la base de datos.

Ejemplo

En mi perfil de GitHub he dejado un ejemplo del proyecto, el cual una vez aplicadas las migraciones sobre la base de datos, podemos ver que funciona correctamente ante la misma lógica de programa de la primera parte:

Nos devolverá:

El alumno Juan recibe el curso de Matematicas,impartido por Pedro
El alumno Jorge recibe el curso de Matematicas,impartido por Pedro
El alumno Sandra recibe el curso de Lenguaje,impartido por Pedro
El alumno Andrea recibe el curso de Lenguaje,impartido por Pedro

En caso de no tener Visual Studio, lanzaremos el proyecto desde el CLI de dotnet con :

dotnet run –proyect PostCore

Aviso a navegantes

En caso de que no queramos almacenar las migraciones, se pueden borrar del proyecto eliminándolas como archivo, o simplemente con:

PM -> remove-migration
CLI -> dotnet ef migrations remove

Pero cada vez que queramos crear una nueva migración y aplicarla, no existirá la migración previa, de manera que tendremos que hacer un drop a la base de datos mediante

PM-> drop-database -Context PostDbContext
CLI-> dotnet ef database dtop -c PostDbContext

asumiendo con ello la consiguiente perdida de datos. En caso contrario, el update lanzará un error indicando que las tablas ya existen en la base de datos.

En entornos de desarrollo, no es necesario revisar la migración ya que presumiblemente no nos importa la posible perdida de datos, pero si vamos a aplicar migraciones en entornos de producción, conviene que revisemos los ficheros generados en la migración, donde veremos que se definen 2 métodos:

Estos dos métodos serán ejecutados durante las actualizaciones de la base de datos (“Up” al aplicar un migración y “Down” al quitarla) y conviene que estemos seguros de que si por ejemplo queremos cambiar como almacenamos los datos de un nombre, unificando dos columnas, hacemos que se genere una nueva columna, se migren los datos de las previas a la nueva, y entonces se borren la previas, de modo que no tengamos una perdida de datos. En cualquier caso, siempre que la migración tenga posibilidades de que se produzca una perdida de información, Entity Framework Core nos lo notificara con el mensaje:

Entity Framework Core

En este enlace, dejo un ejemplo de la documentación oficial detallando más sobre ese tema.

Entradas Relacionadas

Deja un comentario