Code First y Data Annotations en ASP.NET MVC: Introducción y Fundamentos

En este artículo, exploraremos en detalle cómo utilizar Code First en Entity Framework junto con Data Annotations para crear un modelo de datos en ASP.NET MVC. Veremos cómo configurar y validar modelos utilizando atributos, y aplicaremos estos conceptos en un ejemplo práctico de una aplicación de gestión de libros.

¿Qué es Code First?

Code First es una metodología en Entity Framework que permite a los desarrolladores definir el modelo de datos utilizando clases de C# o VB.NET. A partir de estas clases, Entity Framework genera automáticamente la base de datos subyacente y las tablas correspondientes.

Ventajas de Code First

• Control Total del Modelo: Los desarrolladores tienen control total sobre la estructura del modelo de datos mediante clases.
• Mantenimiento Simplificado: Es fácil mantener y evolucionar la base de datos a medida que cambian los requisitos del proyecto.
• Productividad Mejorada: Permite trabajar con objetos en lugar de preocuparse por los detalles de la base de datos.

 

¿Qué son las Data Annotations?

Las Data Annotations son atributos que se aplican directamente a las propiedades de las clases para configurar reglas de validación y otras configuraciones del modelo. Proporcionan una forma declarativa y fácil de entender de especificar metadatos sobre las propiedades de las entidades.

Ventajas de las Data Annotations

• Simplicidad: Fácil de aplicar y entender, especialmente para desarrolladores que están familiarizados con ASP.NET MVC.
• Reutilización: Las mismas reglas de validación pueden aplicarse en diferentes partes del modelo de datos.
• Integración con Herramientas: Se integran de manera nativa con las herramientas de desarrollo y validación de ASP.NET MVC.

 

 

Ejemplo Práctico: Creación del Modelo de Datos con Code First

En esta sección, vamos a abordar la creación del modelo de datos utilizando el enfoque Code First de Entity Framework en un proyecto ASP.NET MVC. El enfoque Code First nos permite definir nuestras entidades y sus relaciones mediante clases C# antes de que la base de datos sea creada. Entity Framework se encargará de generar las tablas y las relaciones en la base de datos basándose en las clases y las configuraciones que proporcionemos.

 

Paso 1: Crear un Nuevo Proyecto ASP.NET MVC

1. Abre Visual Studio.
2. Selecciona Archivo > Nuevo > Proyecto.
3. Selecciona ASP.NET Web Application y elige la plantilla MVC.
4. Asigna un nombre al proyecto, por ejemplo, BookStore.

 

Paso 2: Instalar Entity Framework

Abre la consola del Administrador de Paquetes NuGet (Herramientas > Administrador de Paquetes NuGet > Consola del Administrador de Paquetes) y ejecuta el siguiente comando:

Install-Package EntityFramework

 

Paso 3: Crear el Modelo de Datos

Añade una carpeta Models y crea una clase Book:

using System;
using System.ComponentModel.DataAnnotations;

namespace BookStore.Models
{
    public class Book
    {
        public int BookId { get; set; }
        
        [Required(ErrorMessage = "El título es obligatorio.")]
        [StringLength(100, ErrorMessage = "El título debe tener como máximo 100 caracteres.")]
        public string Title { get; set; }
        
        [Required(ErrorMessage = "El autor es obligatorio.")]
        [StringLength(50, ErrorMessage = "El nombre del autor debe tener como máximo 50 caracteres.")]
        public string Author { get; set; }
        
        [Required(ErrorMessage = "La fecha de publicación es obligatoria.")]
        [Display(Name = "Fecha de Publicación")]
        [DataType(DataType.Date)]
        public DateTime PublishedDate { get; set; }
        
        [Range(0, 1000, ErrorMessage = "El número de páginas debe estar entre 0 y 1000.")]
        public int Pages { get; set; }
        
        [DataType(DataType.Currency)]
        public decimal Price { get; set; }
    }
}

Las Data Annotations, como Required, StringLength, Range, DataType, entre otras, se aplican a las propiedades del modelo Book. Estos atributos especifican reglas de validación y configuraciones adicionales que Entity Framework utiliza durante la creación de la base de datos y la definición de las tablas y columnas correspondientes.

• [Required]: Marca la propiedad como obligatoria, asegurando que el campo correspondiente en la tabla de la base de datos no pueda ser nulo.
• [StringLength]: Limita la longitud máxima de la cadena que puede almacenar la propiedad en la base de datos, aplicando una restricción de longitud.
• [Display(Name = "...")]: Especifica el nombre de visualización de la propiedad, que en este caso se utiliza para cambiar cómo se muestra la etiqueta en las vistas generadas automáticamente.
• [DataType(DataType.Date)]: Especifica el tipo de datos de la propiedad, lo que permite a Entity Framework inferir el tipo de columna adecuado en la base de datos (en este caso, date).
• [Range]: Define el rango permitido de valores numéricos para la propiedad.

Nota: Estas anotaciones proporcionan metadatos adicionales que Entity Framework utiliza para configurar el esquema de la base de datos cuando se aplican migraciones.

 

Paso 4: Configurar el DbContext

Crea o modifica la clase BookContext en la carpeta Models:

using System.Data.Entity;

namespace BookStore.Models
{
    public class BookContext : DbContext
    {
        public BookContext() : base("name=BookContext")
        {
        }

        public DbSet<Book> Books { get; set; }
    }
}

 

Paso 5: Configurar la Cadena de Conexión

Abre el archivo Web.config y añade la cadena de conexión para BookContext:

<connectionStrings>
  <add name="BookContext" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=BookStore;Integrated Security=True" providerName="System.Data.SqlClient" />
</connectionStrings>

 

 

Ejemplo Práctico: La Aplicación de Gestión de Libros

En esta sección, crearemos una aplicación de gestión de libros utilizando ASP.NET MVC y Entity Framework. El objetivo es proporcionar un ejemplo práctico que ilustre cómo configurar un proyecto desde cero, aplicar una migración inicial y utilizar el enfoque Code First junto con Data Annotations para definir y validar nuestros modelos.

 

Paso 1: Crear el Controlador y Vistas

1. Haz clic derecho en la carpeta Controllers y selecciona Agregar > Controlador.
2. Selecciona Controlador MVC 5 con vistas, usando Entity Framework.
3. Asigna el nombre BooksController y selecciona BookContext como el contexto de datos y Book como la clase de modelo.
4. Visual Studio generará automáticamente las vistas CRUD (Crear, Leer, Actualizar, Eliminar) para la entidad Book.

 

Paso 2: Configurar la Base de Datos

Para configurar la base de datos y aplicar migraciones:

1. Habilitar Migraciones

Abre la consola del Administrador de Paquetes NuGet y ejecuta el siguiente comando para habilitar las migraciones:

Enable-Migrations

2. Crear una Migración Inicial

Genera la primera migración con el siguiente comando:

Add-Migration InitialCreate

Esto creará una clase de migración con el esquema inicial de la base de datos basado en tu modelo de datos.

3. Aplicar la Migración

Aplica la migración a la base de datos con el siguiente comando:

Update-Database

Esto creará la base de datos y las tablas necesarias en tu instancia de SQL Server local.

 

Paso 3: Ejecutar la Aplicación

Ejecuta la aplicación y navega a /Books. Deberías poder realizar operaciones CRUD sobre los libros.

 

 

Ejemplo Práctico: Migraciones, Data Annotations y Base de Datos

En el contexto de Entity Framework Code First, al aplicar la migración inicial a la base de datos, los campos de la tabla se configuran en función de las Data Annotations que hayamos aplicado a las propiedades de nuestras entidades. Vamos a explorar detalladamente cómo funciona esto utilizando el ejemplo de este artículo sobre la gestión de libros en ASP.NET MVC.

 

Generación de la Migración:

• Después de definir el modelo de datos y aplicar las Data Annotations, el siguiente paso es generar una migración inicial utilizando Entity Framework.
• Abres la consola del Administrador de Paquetes NuGet y ejecutas el comando

Add-Migration InitialCreate

Este comando analiza el modelo de datos (Book en este caso), y crea una clase de migración con el nombre InitialCreate. Esta clase contiene instrucciones para crear las tablas y configurar los campos según las configuraciones definidas en el modelo, incluyendo las Data Annotations.

La clase de migración generada por Entity Framework se verá algo así:

public partial class InitialCreate : DbMigration
{
    public override void Up()
    {
        CreateTable(
            "dbo.Books",
            c => new
                {
                    BookId = c.Int(nullable: false, identity: true),
                    Title = c.String(nullable: false, maxLength: 100),
                    Author = c.String(nullable: false, maxLength: 50),
                    PublishedDate = c.DateTime(nullable: false),
                    Pages = c.Int(nullable: false),
                    Price = c.Decimal(nullable: false, precision: 18, scale: 2),
                })
            .PrimaryKey(t => t.BookId);
        
    }
    
    public override void Down()
    {
        DropTable("dbo.Books");
    }
}

 

• En el método Up(), que representa la migración hacia adelante, se crea la tabla Books con las columnas correspondientes según las configuraciones definidas en el modelo de Book.
• Observa cómo cada propiedad se configura según las Data Annotations aplicadas:
  • Title y Author tienen especificadas las restricciones de longitud (maxLength).
  • PublishedDate, Pages y Price tienen la configuración nullable y otros atributos que garantizan su validez en la base de datos.

 

Aplicación de la Migración:

• Una vez que la migración está creada y revisada, se aplica a la base de datos utilizando el comando:

Update-Database

Cuando se ejecuta el comando Update-Database en la consola del Administrador de Paquetes NuGet después de habilitar y agregar la migración inicial (Enable-Migrations y Add-Migration InitialCreate respectivamente), Entity Framework genera un script SQL que refleja la estructura definida por el modelo de datos y las Data Annotations.

• Generación de Tablas: Cada clase del modelo (Book en este caso) se traduce en una tabla en la base de datos.
• Configuración de Columnas: Las columnas se crean según el tipo de datos de las propiedades y las configuraciones adicionales como longitud, restricciones de rango y requerimientos de nulidad.
• Validaciones de Datos: Las reglas de validación definidas por las Data Annotations se aplican a nivel de base de datos para garantizar la integridad y consistencia de los datos.

Supongamos que después de aplicar la migración inicial, ejecutamos el comando Update-Database. Entity Framework generará y aplicará el siguiente SQL (simplificado):

CREATE TABLE [dbo].[Books] (
    [BookId] INT IDENTITY(1,1) NOT NULL PRIMARY KEY,
    [Title] NVARCHAR(100) NOT NULL,
    [Author] NVARCHAR(50) NOT NULL,
    [PublishedDate] DATE NOT NULL,
    [Pages] INT NOT NULL,
    [Price] DECIMAL(18,2) NOT NULL
);

Nota: Este script SQL muestra cómo se crea la tabla Books con las columnas correspondientes y las restricciones de nulidad basadas en las Data Annotations aplicadas al modelo Book.

 

 

Conclusiones

En este artículo, hemos explorado cómo utilizar Code First en Entity Framework junto con Data Annotations para configurar y validar modelos en ASP.NET MVC. Hemos creado un modelo básico de libros y hemos aplicado atributos de Data Annotations para definir reglas de validación. Además, hemos visto cómo configurar la base de datos utilizando migraciones para reflejar los cambios en el modelo de datos. Estas técnicas son esenciales para desarrollar aplicaciones robustas y escalables en ASP.NET MVC.