La primera versión de la base de datos de este blog con Entity Framework Code First
En las primeras versiones ASP.NET lo normal era crear una base de datos y posteriormente crear las clases de .NET que representaban las tablas y los registro de la base de datos.
No fue hasta que apareció la versión 3.5 de Entity Framework que se creó la funcionalidad que permitía invertir este flujo. Es decir, poder modificar la base de datos desde las clases de .NET. A este nuevo flujo se le llamó Code-first.
Justamente este flujo es el que he utilizado para crear la base de datos de este blog.
Creando una capa Datos
Para crear una base de datos desde código podría haber utilizado cualquiera de los proyectos ya existentes en la aplicación, pero el diseño del acceso a datos y su persistencia tiene suficiente importancia como para crear un proyecto propio. El hecho de tener los Datos en un proyecto separado permite localizarlo e independizarlo de las demás capas y esto es considerado una buena práctica.
Para crear la capa de datos hay que hacer clic con el botón derecho sobre la solución Solution > Add > New Project
El nombre del proyecto es Blog.Datos, de modo que la solución queda separada en tres proyectos:
- Blog.Datos: capa de acceso y persistencia de los datos
- Blog.Modelo: capa de negocio de la aplicación
- Blog.Web: capa de presentación
Instalar Entity Framework en el proyecto Blog.Datos
Microsoft ofrece un framework especializado en el acceso a base de datos llamado Entity Framework. Este framework es lo que se denomina un ORM (Object-Relational mapping) y su principal propósito es mapear las clases de .NET a registros de una base de datos. En nuestro caso, las clases Post y Tag se convertirán en registros de las tablas Posts y Tags.
Este framework permite trabajar en memoria con los objetos .NET realizando operaciones con ellos. Una vez terminadas las operaciones en memoria se envía a la base de datos una transacción con todos los "inserts", "updates" y "deletes" realizados sobre dichos objetos. ¡No está mal!
Además de poder trabajar con objetos .NET en memoria, como ya he comentado en la introducción, el framework permite crear la base de datos desde el código. A este flujo se le denomina "Code First".
Vamos a ver cómo apliqué "Code-first" en este blog.
Lo primero es instalar Entiy Framework en la capa de datos Blog.Datos > References > Manage NuGet Packages:
En la pestaña Browse el primero que aparece es EntityFramework:
Aparecen un par de diálogos con una previsualización de los cambios y unas condiciones de uso:
Una vez finalizada la instalación, el proyecto tiene nuevas referencias al EntityFramework. Además se crea un archivo llamado "packages.config" que sirve para llevar un seguimiento de las versiones instaladas en el proyecto:
No entraré a explicar los detalles del archivo "packages.config", tan solo os comento que su utilidad es la de poder mantener actualizados los proyectos de terceros, como es el caso de EntityFramework.
Crear la clase contexto de la base de datos (DbContext)
La clave del funcionamiento de EF es la clase DbContext. Esta clase es la que permite consultar, crear, editar y eliminar registros en una base de datos. Así que si quieres trabajar con EF lo primero que debes hacer es crear una clase que implemente DbContext.
Clase DbContext:
La nueva clase que he llamado ContextoBaseDatos hereda de DbContext y se divide en un constructor y unas propiedades:
- El constructor llama a su vez al contructor base pasándole el nombre de una cadena de conexión.
- Las dos propiedades añadidas son del tipo DbSet<T>, concretamente DbSet<Post> y DbSet<Tag>.
Con esta implementación estamos indicando que la base de datos tenga una tabla Posts y una tabla Tags, y que cada uno de sus registros se pueda mapear con nuestros objetos de Modelo Post y Tag.
Todo esto es posible porque el framework está usando convenciones estándar para crear las tablas, las claves primarias y los campos de las tablas. Estas convenciones por defecto són las más utilizadas "en teoría", pero si te interesa las puedes modificar a tu gusto sobreescribiendo uno de los métodos de DbContext (en otra entrada veremos cómo).
Al utilizar las clases Post y Tag dentro de nuestro ContextoBaseDatos debemos establecer una depencencia con la capa Modelo (debido al uso de DbSet<Tag>()). Esto significa que hay que añadir una referencia a Modelo:
En la pestaña de Proyectos aparecen todos los proyectos que usa la solución. Podemos seleccionar Blog.Modelo para añadir la referencia:
Con esta clase ContextoBaseDatos implementada y combinada con la plantilla MVC5 por defeto que hemos utilizado al iniciar este blog ya tendríamos suficiente para trabajar con una base de datos, pero...
¿Dónde está mi base de datos?
Antes he comentado que el constuctor de DbContext recibe como parámetro el nombre de la cadena de conexión. Esta cadena de conexión se ha creado por defecto en el archivo web.config de la capa de presentación Blog.Web:
ACTUALIZACIÓN: La cadena de conexión se generaba al instalar el paquete EntityFramework a través de Nuget. Si no se genera automáticamente, añádela a mano.
El atributo "connectionString" contiene la cadena de conexión de la base de datos y con ello podemos averiguar dónde se encuentra la base de datos. En este caso, la cadena de conexión está apuntando a una base de datos (LocalDb).
LocalDB es una versión ligera del motor de base de SQL Server Express que se ejecuta en la máquina local. En lugar de necesitar un servidor de base de datos simplemente utiliza archivos .mdf que por defecto se crean en la carpeta App_Data del proyecto web, y que permiten trabajar normalmente como si de una base de datos real se tratase.
Microsoft no recomienda trabajar con este tipo de base de datos en un entorno real, con lo cual nos obligará a pensar dónde colocaremos nuestra base de datos real. Por ahora, continuamos con la base de datos LocalDb.
Si has seguido al pie de la letra los mismos pasos que he descrito verás que en la carpeta App_Data del proyecto todavía no hay ningún archivo. Aquí entra en juego otro nuevo concepto de EF: Las migraciones "Migrations".
Migrations: creando la base de datos desde la línea de comandos de Visual Studio
Las "Migrations" son una funcionalidad de EF que permiten crear y modificar bases de datos desde una línea de comandos del Visual Studio. Es la funcionalidad principal del flujo "Code First".
Para utilizar esta funcionalidad solamente hay que recordar tres comandos:
- Enable-migrations
- Add-migration
- Update-dabase
Estos tres comandos se ejecutan desde el Package Manager Console:
El primero de ellos, enable-migrations, sirve para indicar que vamos a trabajar con esta funcionalidad de EF.
¡Ojo! Es importante que al trabajar con Package-Manager-Console indiquemos el proyecto donde estamos ejecutando los comandos. En este caso Default project: Blog.Datos:
Al ejecutar "enable-migrations" se crea una carpeta nueva en la capa de datos con el nombre Migrations y un archivo Configuration.cs:
A partir de este momento cada vez que se realicen cambios en las clases entidad que aparecen en la clase DbContext se podrán enviar a la base de datos y actualizarla en consecuencia.
¿Cómo se envían los cambios a la base de datos?
Utilizando los dos comandos restantes. Primero el que detecta los cambios Add-migration.
En nuestro caso ni siquiera está creada la base de datos, por tanto, en la primera migración que creemos se debe detectar la clase Post y Tag:
- Add-Migration NombreDeLaMigracion
Normalmente a la primera migración se la denomina Inicial:
Esta acción crea un archivo en la carpeta Migrations que representa un script con los cambios que debería hacer en la base de datos para sincronizarse con las clases de .NET
Contenido de 201602191553402_Inicial.cs:
El archivo contiene dos métodos Up y Down. "Up" representa el script de sql que crearía las tablas Tags y Posts así como sus propiedades. Mientras que "Down" viene a ser el script que ejecutándose dejaría la base de datos en el estado anteior a haberse ejecutado "Up"
El código generado es C# y se puede modificar sin problemas.
Sólo faltaría enviar y ejecutar estos cambios a la base de datos.
Para ello se usa el comando:
- update-database
Vamos con él:
Si todo ha ido bien, la base de datos se ha creado y por tanto puedes ver sus archivos en la carpeta App_data:
Si quieres editar la base de datos lo puedes hacer desde el Server Explorer del Visual Studio. Puedes acceder a través del menú "View":
Esta es la estructura de la primera versión de la base de datos de este blog:
Si más adelante realizamos una modificación sobre una de las dos entidades Post o Tag y queremos notificar el cambio a la base de datos simplemente debemos repetir los pasos indicados.
- Add-Migration NombreDescriptivoDeLosCambios: creará otro archivo de migración que solamente tendrá las modificaciones desde los últimos cambios detectados.
- Update-database: para actualizar la base de datos.
Recapitulando
- El acceso a datos de este blog está separado en capa específica e independiente.
- La tecnología usada para el acceso a datos es Entity Framework.
- La clase principal de EF es DbContext y permite consultar, crear, editar y eliminar registros de una base de datos.
- La base de datos de este blog se creó utilizando la funcionalidad "Migrations" de Entity Framework.
- Los comandos principales de Migrations son: enable-migrations, add-migration, update-database.
Y así fue como creé la primera versión de la base de datos de este blog. :)