Haciendo fácil el acceso a datos con Entity Framework Core

Entity Framework Core

Si después de leer esta entrada estas interesado en el Entity Framework Core, ya esta disponible la versión 3.0 y trae muchas novedades.

Segunda entrada en el blog y vengo a hablaros de otra situación que se dio en mi oficina… Otro compañero acaba de meterse en un proyecto de uso intensivo de bases de datos en el que requiere de una herramienta que le solucione la papeleta.

En mi día a día, he trabajado bastante con Entity Framework 6, el «clásico», pero hace algún tiempo encontré Entity Framework Core . Entity Framework Core partió con un set de herramientas bastante limitado, no habiendo comparación posible con su «hermano mayor» Entity Framework 6. Pese a todo, Entity Framework Core fue diseñado con la filosofía de la era «cloud«, y estaba super optimizado para las cosas que hacía. Todo esto ha cambiado con la versión 2.0, (os dejo un enlace con la comparación y set de utilidades).

En el momento actual, tenemos entre manos una herramienta que si bien no es tan madura como Entity Framework 6, si tiene un madurez a tener en cuenta. Un punto a favor muy fuerte que tiene, es su posibilidad de ejecución multiplataforma, lo cual, nos permite usarlo con .Net Framweork o con .Net Core (¡y eso a mi me encanta!).

Una vez dicho esto, vamos a meternos en faena… ¿Como resolvimos esto? Como es de suponer, ¡¡¡con Entity Framework Core!!!. En este caso, como se dispone del modelo de la base de datos, utilizamos la opción «Database First». Aunque también existe la opción «Code First», para que la base de datos se genere desde el código, y hablaremos de ella en otro post…

Modelo

Modelo DB

Para este caso, he creado un modelo como este:

En el tenemos 2 relaciones 1 a muchos:

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

En este caso, utilizaré para el ejemplo una base de datos MySql, al ser una base de datos gratuita.

Teniendo claro el modelo, vamos al lío!

Creando la solución

Lo primero, sera crear un proyecto de consola en c# y .Net Framework (o .Net Core, lo que se prefiera):

consola .net full

Paquetes

Con el proyecto creado, vamos a descargar los paquetes de Entity Framework Core vía NuGet:

La imagen muestra el paquete Entity FRamework Core
La imagen muestra el paquete Entity FRamework Core Tools

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

Solo falta descargar el proveedor de datos,en este caso MySql, y para eso, vamos a utilizar una implementación que va muy bien con Entity Framework Core:

La imagen muestra el paquete Pomelo para Entity Framework Core

O como siempre, por consola:

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

Generando el DbContext

Una vez que tenemos todo instalado, vamos a ejecutar la generación del contexto. Para eso, usaremos el comando «scaffold» en la Consola de Administrador de Paquetes (No, Entity Framework Core no dispone de interfaz. Pero no requiere más que de unos pocos comandos, vamos, que no va a ser muy duro).

PM->scaffold-dbcontext "Server=localhost;Database=postefcore;Uid=root;Pwd=root;" Pomelo.EntityFrameworkCore.Mysql -outputdir Models -context PostDbContext

Analicemos los argumentos:

  1. -dbcontext
  2. -outputdir
  3. -context

En «dbcontext» le estamos pasando el contexto que queremos utilizar. Utilizaremos una cadena de conexión y un proveedor Entity Framework Core para eso. En este caso Pomelo.EntityFrameworkCore.Mysql, si utilizáramos otro, tendríamos que indicarlo aquí.

En «outputdir» le indicamos la ruta en nuestro proyecto donde queremos que cree las clases necesarias para funcionar.

En «context» le indicamos el nombre que le queremos dar a nuestro contexto de datos.

Una vez termine la ejecución, veremos algo como esto en nuestro proyecto:

Contexto

En caso de que lo que queramos sea actualizar el modelo porque hemos hecho cambios en la db, lo haríamos con el siguiente comando:

PM->scaffold-dbcontext "Server=localhost;Database=postefcore;Uid=root;Pwd=root;" Pomelo.EntityFrameworkCore.Mysql -outputdir Models -context PostDbContext -force

En este caso, hemos añadido el argumento – force para que sobre escriba lo que hay.

Puedes leer más sobre los argumentos aquí.

Insertando datos

Con esto que hemos hecho, ya podemos acceder a la base de datos mediante el ORM, y operarla como necesitemos, por ejemplo, vamos a añadir 1 profesor, 2 cursos y 4 alumnos. Para ello, insertamos el siguiente código en nuestra clase program:

 
using (PostDbContext context = new PostDbContext())
{
    //Creamos el profesor
    Profesores profesor = new Profesores() {Nombre = "Pedro" };
    context.Add(profesor);
    //Creamos los cursos
    Cursos curso1 = new Cursos() { Nombre = "Matematicas", IdProfesor = profesor.IdProfesor };
    context.Add(curso1);
    Cursos curso2 = new Cursos() { Nombre = "Lenguaje", IdProfesor = profesor.IdProfesor };
    context.Add(curso2);
    //Creamos los alumnos
    Alumnos alumno1 = new Alumnos() { Nombre = "Jorge", IdCurso = curso1.IdCurso };
    context.Add(alumno1);
    Alumnos alumno2 = new Alumnos() { Nombre = "Juan", IdCurso = curso1.IdCurso };
    context.Add(alumno2);
    Alumnos alumno3 = new Alumnos() { Nombre = "Andrea", IdCurso = curso2.IdCurso };
    context.Add(alumno3);
    Alumnos alumno4 = new Alumnos() { Nombre = "Sandra", IdCurso = curso2.IdCurso };
    context.Add(alumno4);
    //Guardamos los cambios
    context.SaveChanges();
}

Pese a que las tablas requieren de IDs de las relaciones, y que la consulta no se ejecuta hasta llamar a SaveChanges(), Entity Framework Core es capaz de almacenar las relaciones y asignar los IDs correspondientes. Así evitamos tener que hacer una consulta para obtener el ID del profesor, antes de de añadírselo a un curso, o el id de un curso antes de añadírselo a un alumno. Esto es una gran ventaja, ya que evita la necesidad de una función, o de dos consultas a la base de datos. Por otro lado, cuando ejecutamos la llamada a SaveChanges(), Entity Framework Core rellena los datos de ids con los valores que se han asignado en la base de datos.

Leyendo datos

Ahora, vamos a leer datos aprovechando la navegación de propiedades. Con ella, vamos a obtener un profesor. Con el profesor,obtendremos todos sus alumnos sin necesidad de ejecutar varias consultas o un largo «inner join». Para eso, insertamos el siguiente código:

 
using (PostDbContext context = new PostDbContext())
{
    var profesor = context.Profesores //Indicamos la tabla
                          .Include(x => x.Cursos) //Incluimos los resultados coincidentes de la tabla cursos (inner join)
                          .ThenInclude(x => x.Alumnos) //Incluimos los resultados coincidentes de la tabla alumnos (inner join)
                          .First(); //Seleccionamos el primero
    foreach (var curso in profesor.Cursos)
      foreach (var alumno in curso.Alumnos)
        Console.WriteLine($"El alumno {alumno.Nombre} recibe el curso de {curso.Nombre},impartido por {profesor.Nombre}");
}

(Para que podamos utilizar .Include, hay que añadir el using correspondiente)

 
using Microsoft.EntityFrameworkCore;

Obteniendo por consola algo así:

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

Lo cual vemos que coincide con los datos que hemos introducido, aportándonos así este ORM un nivel de abstracción que nos puede facilitar mucho la vida. Por no hablar de la posibilidad de realizar todo esto de manera asíncrona. Todo ello de manera transparente a nosotros, y sin ninguno esfuerzo adicional.

Cabe destacar, que aunque no lo he indicado expresamente, Entity Framework Core nos permite trabajar con las tablas de la base de datos mediante LinQ. De este modo,podemos trabajar con la base de datos sin necesidad de utilizar sentencias SQL, con una herramienta fuertemente tipada.

En el próximo post, hablaremos de la opción «Code First», y ahondaremos en las bondades que nos aporta utilizar un Entity Framework Core.

Deja un comentario