Integración de ASP.NET Core con Entity Framework Core (I)

En este artículo, exploraremos cómo integrar Entity Framework (EF) con ASP.NET Core para gestionar la capa de acceso a datos de nuestras aplicaciones web. Entity Framework es un ORM (Mapeador Objeto-Relacional) desarrollado por Microsoft, que simplifica la interacción con bases de datos relacionales utilizando objetos de dominio en lugar de consultas SQL directas.

¿Qué es Entity Framework?

Entity Framework es un framework ORM que permite a los desarrolladores trabajar con datos en forma de objetos de dominio, eliminando la necesidad de escribir consultas SQL manualmente. Proporciona una abstracción sobre la base de datos subyacente y facilita las operaciones CRUD (Crear, Leer, Actualizar, Eliminar) mediante el uso de clases y consultas LINQ (Language Integrated Query).

Configuración del Proyecto

Antes de comenzar a trabajar con Entity Framework en ASP.NET Core, necesitamos configurar nuestro proyecto. En primer lugar, asegúrate de tener instalado el paquete NuGet de Entity Framework Core:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer

Este paquete nos permite trabajar con una base de datos SQL Server, pero Entity Framework Core también es compatible con otros motores de bases de datos.

Luego, en el archivo Startup.cs, dentro del método ConfigureServices, agregamos el contexto de la base de datos:

services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

Aquí ApplicationDbContext es la clase que representa el contexto de nuestra base de datos y DefaultConnection es la cadena de conexión a nuestra base de datos SQL Server, que debe estar definida en el archivo appsettings.json.

Creación del Modelo de Datos

Una vez configurado Entity Framework en nuestro proyecto, podemos comenzar a definir nuestros modelos de datos. Estos modelos representarán las tablas de nuestra base de datos y serán mapeados a través del contexto de la base de datos.

Por ejemplo, supongamos que queremos crear un modelo de datos para una tabla de usuarios. Podríamos definir la siguiente clase:

public class Usuario
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public string Email { get; set; }
}

Creación del Contexto de la Base de Datos

El contexto de la base de datos es una clase que hereda de DbContext y representa la conexión con la base de datos. Define las tablas y relaciones entre ellas, así como las configuraciones de mapeo y otras opciones de configuración.

using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    // Propiedad que representa la tabla de usuarios en la base de datos
    public DbSet<Usuario> Usuarios { get; set; }

    // Constructor que recibe las opciones de configuración del contexto
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }

    // Método que configura el modelo de datos y otras opciones del contexto
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        // Configuración del mapeo de la clase Usuario a la tabla Usuarios en la base de datos
        modelBuilder.Entity<Usuario>(entity =>
        {
            entity.ToTable("Usuarios"); // Nombre de la tabla en la base de datos
            entity.HasKey(e => e.Id); // Definición de la clave primaria
            entity.Property(e => e.Nombre).IsRequired(); // Definición de una columna requerida
            entity.Property(e => e.Email).IsRequired().HasMaxLength(100); // Definición de una columna requerida con longitud máxima
        });
    }
}

En este ejemplo, hemos definido una clase ApplicationDbContext que hereda de DbContext. La clase tiene una propiedad Usuarios que representa la tabla de usuarios en la base de datos. El constructor recibe las opciones de configuración del contexto, que generalmente se pasan desde el método ConfigureServices en Startup.cs.

Además, hemos sobrescrito el método OnModelCreating para configurar el modelo de datos y definir el mapeo de la clase Usuario a la tabla Usuarios en la base de datos. En este método, podemos definir las claves primarias, las propiedades de las columnas y otras configuraciones específicas de la base de datos.

Esta es solo una muestra básica de cómo se puede configurar el contexto de la base de datos en Entity Framework Core. Dependiendo de las necesidades de tu aplicación, es posible que desees agregar más configuraciones y definiciones de modelos.

Operaciones CRUD con Entity Framework

Una vez que hemos definido nuestros modelos y el contexto de la base de datos, podemos realizar operaciones CRUD (Crear, Leer, Actualizar, Eliminar) utilizando Entity Framework. A continuación, mostraremos ejemplos de cómo realizar estas operaciones.

Crear (Create)

Para crear un nuevo registro en la base de datos, simplemente creamos una instancia del modelo correspondiente, la agregamos al DbSet correspondiente en el contexto y luego llamamos al método SaveChanges() para guardar los cambios en la base de datos.

var nuevoUsuario = new Usuario
{
    Nombre = "Rafael",
    Email = "Rafael@example.com"
};

using (var context = new ApplicationDbContext())
{
    context.Usuarios.Add(nuevoUsuario);
    context.SaveChanges();
}

Leer (Read)

Para leer datos de la base de datos, podemos utilizar métodos LINQ como ToList(), FirstOrDefault(), Find() y otros para recuperar los registros de la base de datos.

using (var context = new ApplicationDbContext())
{
    // Obtener todos los usuarios
    var todosLosUsuarios = context.Usuarios.ToList();

    // Obtener el primer usuario con el nombre "Rafael"
    var usuarioRafael = context.Usuarios.FirstOrDefault(u => u.Nombre == "Rafael");

    // Obtener un usuario por su id
    var usuarioPorId = context.Usuarios.Find(1);
}

Actualizar (Update)

Para actualizar un registro en la base de datos, primero lo buscamos utilizando uno de los métodos de lectura mencionados anteriormente, actualizamos sus propiedades y luego llamamos a SaveChanges() para guardar los cambios.

using (var context = new ApplicationDbContext())
{
    var usuario = context.Usuarios.FirstOrDefault(u => u.Nombre == "Rafael");
    if (usuario != null)
    {
        usuario.Nombre = "Rafael Acosta";
        context.SaveChanges();
    }
}

Eliminar (Delete)

Para eliminar un registro de la base de datos, lo buscamos utilizando uno de los métodos de lectura mencionados anteriormente y luego lo eliminamos del DbSet correspondiente en el contexto y llamamos a SaveChanges() para guardar los cambios.

using (var context = new ApplicationDbContext())
{
    var usuario = context.Usuarios.FirstOrDefault(u => u.Nombre == "Rafael Acosta");
    if (usuario != null)
    {
        context.Usuarios.Remove(usuario);
        context.SaveChanges();
    }
}

Estos son solo algunos ejemplos básicos de cómo realizar operaciones CRUD con Entity Framework en ASP.NET Core. Dependiendo de las necesidades específicas de tu aplicación, es posible que necesites realizar operaciones más complejas o utilizar métodos adicionales proporcionados por Entity Framework.

Conclusiones

En este artículo, hemos explorado detalladamente cómo integrar Entity Framework con ASP.NET Core para gestionar la capa de acceso a datos de nuestras aplicaciones web. Entity Framework ofrece numerosas ventajas para el desarrollo de aplicaciones, incluyendo:

Abstracción de la Base de Datos

Entity Framework proporciona una abstracción sobre la base de datos subyacente, lo que permite a los desarrolladores trabajar con objetos de dominio en lugar de preocuparse por los detalles de la implementación de la base de datos. Esto simplifica enormemente el desarrollo de aplicaciones al eliminar la necesidad de escribir consultas SQL manualmente y alinear el código con el modelo de objetos de la aplicación.

Mapeo Objeto-Relacional (ORM)

Entity Framework ofrece un mapeo objeto-relacional (ORM) completo y flexible que permite mapear clases de objetos de dominio a tablas de base de datos y viceversa. Este mapeo se realiza mediante atributos o configuraciones fluídas, lo que brinda un alto grado de personalización y control sobre cómo se persisten los datos en la base de datos.

Consultas LINQ

Entity Framework permite realizar consultas utilizando LINQ (Language Integrated Query), lo que proporciona un lenguaje de consulta integrado y tipado estáticamente dentro del lenguaje de programación C#. Esto simplifica la escritura de consultas y hace que el código sea más legible y mantenible al tiempo que ofrece la capacidad de comprobar errores en tiempo de compilación.

Soporte de Transacciones y Concurrencia

Entity Framework ofrece soporte integrado para transacciones de base de datos y control de concurrencia, lo que garantiza la integridad de los datos y la consistencia en entornos multiusuario. Además, permite el uso de bloqueos optimistas y pesimistas para manejar conflictos de concurrencia y asegurar la coherencia de los datos en escenarios de acceso concurrente.

Migraciones de Base de Datos

Entity Framework facilita la administración de esquemas de base de datos mediante el uso de migraciones automáticas. Las migraciones permiten realizar cambios en el esquema de la base de datos de manera controlada y automatizada, lo que simplifica el proceso de desarrollo y despliegue de la aplicación al garantizar que el esquema de la base de datos esté siempre sincronizado con el modelo de datos de la aplicación.

Resumen 

La integración de Entity Framework con ASP.NET Core ofrece una solución completa y robusta para el acceso a datos en aplicaciones web, permitiendo a los desarrolladores centrarse en la lógica de negocio de la aplicación sin preocuparse por los detalles de la implementación de la base de datos. Con su amplio conjunto de características y su sólido soporte por parte de Microsoft, Entity Framework es una elección sólida para el desarrollo de aplicaciones web en el ecosistema de .NET.

Continuación: En el siguiente artículo Integración de ASP.NET Core con Entity Framework Core (II) , desarrollaremos una aplicación web utilizando ASP.NET Core y Entity Framework en Visual Studio. Utilizaremos Entity Framework para interactuar con una base de datos y realizar operaciones CRUD (Crear, Leer, Actualizar, Eliminar) sobre entidades de datos. Además, implementaremos vistas ASP.NET para mostrar y manipular los datos en nuestra aplicación web.