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

En este artículo, vamos a desarrollar 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.

Creación del Proyecto en Visual Studio

1. Abre Visual Studio y selecciona "Crear un nuevo proyecto".
2. En el cuadro de diálogo "Nuevo proyecto", elige la plantilla "Aplicación web ASP.NET Core" y haz clic en "Siguiente".
3. Especifica un nombre y una ubicación para tu proyecto y haz clic en "Crear".
4. En la ventana "Crear un nuevo proyecto ASP.NET Core", elige la plantilla "Aplicación web de ASP.NET Core" y selecciona la versión de ASP.NET Core que prefieras.
5. Haz clic en "Crear" para crear el proyecto.

Configuración de Entity Framework Core

1. Instalación de paquetes

El primer paso es instalar los paquetes necesarios de Entity Framework. Utilizaremos el paquete Microsoft.EntityFrameworkCore.SqlServer, que proporciona las herramientas necesarias para trabajar con una base de datos SQL Server en nuestra aplicación.

Abre el Administrador de Paquetes NuGet desde la barra de menú: "Herramientas" -> "Administrador de Paquetes NuGet" -> "Consola del Administrador de Paquetes".

Ejecuta el siguiente comando en la consola del Administrador de Paquetes NuGet para instalar el paquete:

Install-Package Microsoft.EntityFrameworkCore.SqlServer

Este comando instalará el paquete Microsoft.EntityFrameworkCore.SqlServer y todas sus dependencias en tu proyecto.

2. Creación del Contexto de la Base de Datos

El siguiente paso es crear el contexto de la base de datos. El contexto es una clase que hereda de DbContext y representa la conexión con la base de datos. En el contexto, se definen los DbSet correspondientes a cada entidad de datos y se configuran las relaciones entre ellas.

Crea una clase llamada ApplicationDbContext en un archivo llamado ApplicationDbContext.cs en la carpeta Data de tu proyecto:

using Microsoft.EntityFrameworkCore;

namespace TuProyecto.Data
{
    public class ApplicationDbContext : DbContext
    {
        public DbSet<Usuario> Usuarios { get; set; }

        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
            : base(options)
        {
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            // Configuraciones de mapeo de entidades aquí
        }
    }
}

En esta clase, hemos definido un DbSet llamado Usuarios que representa la tabla de usuarios en la base de datos. También hemos sobrescrito el método OnModelCreating para configurar el modelo de datos y definir el mapeo de entidades.

3. Configuración del Contexto en el Servicio de Inyección de Dependencias

Una vez que hemos creado el contexto de la base de datos, necesitamos configurarlo en el servicio de inyección de dependencias para que pueda ser utilizado en otras partes de la aplicación.

Abre el archivo Startup.cs en la raíz de tu proyecto y agrega el siguiente código en el método ConfigureServices:

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

Este código registra el contexto de la base de datos en el servicio de inyección de dependencias y configura la conexión a la base de datos SQL Server utilizando la cadena de conexión especificada en el archivo appsettings.json.

4. Configuración de la Cadena de Conexión

Por último, necesitamos configurar la cadena de conexión a la base de datos en el archivo appsettings.json. Abre este archivo y agrega la siguiente configuración dentro del bloque "ConnectionStrings":

"ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=TuBaseDeDatos;Trusted_Connection=True;MultipleActiveResultSets=true"
}

En esta configuración, reemplaza "TuBaseDeDatos" con el nombre de tu base de datos en SQL Server.

Configuración de las Vistas ASP.NET

1. Crea una carpeta "Views" en tu proyecto para almacenar tus vistas ASP.NET.
2. Crea vistas ASP.NET para mostrar y manipular los datos de tu aplicación. Por ejemplo, crea una vista Usuarios/Index.cshtml para mostrar una lista de usuarios.

@model IEnumerable<Usuario>

<h2>Lista de Usuarios</h2>

<table class="table">
    <thead>
        <tr>
            <th>Id</th>
            <th>Nombre</th>
            <th>Email</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var usuario in Model)
        {
            <tr>
                <td>@usuario.Id</td>
                <td>@usuario.Nombre</td>
                <td>@usuario.Email</td>
            </tr>
        }
    </tbody>
</table>

Implementación de Controladores

1. Crea un controlador llamado UsuariosController para manejar las operaciones CRUD de los usuarios.

public class UsuariosController : Controller
{
    private readonly ApplicationDbContext _context;

    public UsuariosController(ApplicationDbContext context)
    {
        _context = context;
    }

    // GET: Usuarios
    public async Task<IActionResult> Index()
    {
        return View(await _context.Usuarios.ToListAsync());
    }

    // GET: Usuarios/Crear
    public IActionResult Crear()
    {
        return View();
    }

    // POST: Usuarios/Crear
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Crear([Bind("Id,Nombre,Email")] Usuario usuario)
    {
        if (ModelState.IsValid)
        {
            _context.Add(usuario);
            await _context.SaveChangesAsync();
            return RedirectToAction(nameof(Index));
        }
        return View(usuario);
    }

    // GET: Usuarios/Editar/5
    public async Task<IActionResult> Editar(int? id)
    {
        if (id == null)
        {
            return NotFound();
        }

        var usuario = await _context.Usuarios.FindAsync(id);
        if (usuario == null)
        {
            return NotFound();
        }
        return View(usuario);
    }

    // POST: Usuarios/Editar/5
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Editar(int id, [Bind("Id,Nombre,Email")] Usuario usuario)
    {
        if (id != usuario.Id)
        {
            return NotFound();
        }

        if (ModelState.IsValid)
        {
            try
            {
                _context.Update(usuario);
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UsuarioExists(usuario.Id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }
            return RedirectToAction(nameof(Index));
        }
        return View(usuario);
    }

    // GET: Usuarios/Eliminar/5
    public async Task<IActionResult> Eliminar(int? id)
    {
        if (id == null)
        {
            return NotFound();
        }

        var usuario = await _context.Usuarios
            .FirstOrDefaultAsync(m => m.Id == id);
        if (usuario == null)
        {
            return NotFound();
        }

        return View(usuario);
    }

    // POST: Usuarios/Eliminar/5
    [HttpPost, ActionName("Eliminar")]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> EliminarConfirmado(int id)
    {
        var usuario = await _context.Usuarios.FindAsync(id);
        _context.Usuarios.Remove(usuario);
        await _context.SaveChangesAsync();
        return RedirectToAction(nameof(Index));
    }

    private bool UsuarioExists(int id)
    {
        return _context.Usuarios.Any(e => e.Id == id);
    }
}

Conclusiones

En este artículo, hemos profundizado en la configuración de Entity Framework para trabajar con una base de datos SQL Server en una aplicación ASP.NET Core. Entity Framework es una herramienta poderosa que simplifica la interacción con la base de datos al proporcionar un ORM (Mapeador Objeto-Relacional) robusto y altamente configurable.

Simplificación del Acceso a Datos

Entity Framework elimina gran parte del código repetitivo asociado con el acceso a la base de datos. Al definir modelos de datos y configurar el contexto de la base de datos, podemos realizar operaciones CRUD con facilidad utilizando métodos simples y familiares de LINQ.

Flexibilidad y Personalización

Una de las fortalezas de Entity Framework es su flexibilidad y capacidad de personalización. A través del método OnModelCreating, podemos configurar el modelo de datos y definir el mapeo de entidades de manera granular, lo que nos permite adaptar Entity Framework a las necesidades específicas de nuestra aplicación.

Gestión de Transacciones y Concurrencia

Entity Framework también proporciona soporte para la gestión de transacciones y la concurrencia. Podemos utilizar transacciones explícitas para agrupar varias operaciones en una sola unidad atómica, garantizando la consistencia de los datos. Además, Entity Framework maneja automáticamente la concurrencia optimista, detectando y resolviendo conflictos cuando varios usuarios intentan modificar los mismos datos simultáneamente.

Rendimiento y Optimización

Si bien Entity Framework simplifica el desarrollo de aplicaciones web, es importante tener en cuenta consideraciones de rendimiento y optimización al trabajar con grandes conjuntos de datos. Mediante técnicas como el eager loading, el lazy loading y el uso de consultas optimizadas, podemos mejorar el rendimiento de nuestras consultas y minimizar la carga en el servidor de base de datos.

Integración con Herramientas de Desarrollo

Entity Framework se integra estrechamente con otras herramientas de desarrollo de Microsoft, como Visual Studio y Azure DevOps. Esto facilita el desarrollo, la depuración y la implementación de aplicaciones ASP.NET Core, proporcionando un flujo de trabajo fluido y eficiente para los desarrolladores.

 

Resumen: Entity Framework es una opción sólida para el desarrollo de aplicaciones web en el ecosistema de .NET. Su capacidad para simplificar el acceso a la base de datos, su flexibilidad y personalización, su soporte para la gestión de transacciones y la concurrencia, y su integración con otras herramientas de desarrollo hacen de Entity Framework una herramienta valiosa para los desarrolladores de ASP.NET Core.