Cómo crear un CRUD profesional en .NET 10 con buenas prácticas

Las operaciones CRUD (Create, Read, Update y Delete) son la base de la mayoría de aplicaciones empresariales. Aunque a simple vista parecen sencillas, un CRUD bien diseñado puede marcar la diferencia entre una aplicación fácil de mantener y una que se vuelve difícil de escalar con el tiempo. Con .NET 10 y las últimas versiones de C#, los desarrolladores disponen de herramientas modernas para construir soluciones robustas, seguras y eficientes siguiendo estándares profesionales.

¿Qué es un CRUD?

CRUD es el conjunto de operaciones fundamentales que permiten gestionar información dentro de una base de datos:

• Create: Crear registros.
• Read: Consultar información.
• Update: Actualizar datos existentes.
• Delete: Eliminar registros.

Prácticamente cualquier sistema empresarial utiliza estas operaciones, desde plataformas de comercio electrónico hasta sistemas de gestión de inventario o aplicaciones financieras.

Diseñando una arquitectura profesional

Uno de los errores más comunes al desarrollar una API es colocar toda la lógica dentro de los controladores. Aunque funciona en proyectos pequeños, esta práctica genera código difícil de mantener.

La recomendación es utilizar una arquitectura por capas:

Capa Domain

Contiene las entidades y reglas de negocio.

public class Producto
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public decimal Precio { get; set; }
    public int Stock { get; set; }
}

Esta capa debe permanecer independiente de bases de datos, frameworks y servicios externos.

Capa Application

Aquí se implementan los casos de uso, DTOs, validaciones y servicios que gestionan la lógica de la aplicación.

Los DTOs permiten controlar exactamente qué información se envía y recibe desde la API.

public class CrearProductoDto
{
    public string Nombre { get; set; }
    public decimal Precio { get; set; }
}

Capa Infrastructure

Gestiona el acceso a datos utilizando Entity Framework Core.

En esta capa se configuran:

• DbContext
• Repositorios
• Migraciones
• Conexiones a bases de datos

Capa API

Es la puerta de entrada para clientes externos mediante endpoints HTTP.

Implementando Entity Framework Core

Entity Framework Core sigue siendo la opción más utilizada para trabajar con bases de datos en .NET.

El contexto puede definirse así:

public class AppDbContext : DbContext
{
    public DbSet<Producto> Productos { get; set; }

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

Posteriormente se registra en Program.cs:

builder.Services.AddDbContext<AppDbContext>(
    options => options.UseSqlServer(
        builder.Configuration.GetConnectionString("DefaultConnection")));

Creando los endpoints CRUD

Una API profesional suele exponer rutas RESTful claras y consistentes.

Obtener todos los productos

[HttpGet]
public async Task<IActionResult> Get()
{
    var productos = await _context.Productos.ToListAsync();
    return Ok(productos);
}

Obtener un producto por ID

[HttpGet("{id}")]
public async Task<IActionResult> GetById(int id)
{
    var producto = await _context.Productos.FindAsync(id);

    if(producto == null)
        return NotFound();

    return Ok(producto);
}

Crear un producto

[HttpPost]
public async Task<IActionResult> Post(CrearProductoDto dto)
{
    var producto = new Producto
    {
        Nombre = dto.Nombre,
        Precio = dto.Precio
    };

    _context.Productos.Add(producto);
    await _context.SaveChangesAsync();

    return CreatedAtAction(nameof(GetById),
        new { id = producto.Id }, producto);
}

Actualizar un producto

[HttpPut("{id}")]
public async Task<IActionResult> Put(int id, Producto producto)
{
    if(id != producto.Id)
        return BadRequest();

    _context.Update(producto);
    await _context.SaveChangesAsync();

    return NoContent();
}

Eliminar un producto

[HttpDelete("{id}")]
public async Task<IActionResult> Delete(int id)
{
    var producto = await _context.Productos.FindAsync(id);

    if(producto == null)
        return NotFound();

    _context.Productos.Remove(producto);
    await _context.SaveChangesAsync();

    return NoContent();
}

Buenas prácticas recomendadas

Utilizar programación asíncrona

Siempre que sea posible, utiliza async y await para evitar bloqueos innecesarios y mejorar la escalabilidad.

Implementar validaciones

Herramientas como FluentValidation permiten centralizar reglas de negocio y mantener controladores limpios.

Ejemplo:

RuleFor(x => x.Nombre)
    .NotEmpty()
    .MaximumLength(100);

Manejo global de excepciones

Implementar middleware de errores permite devolver respuestas uniformes y mejorar la experiencia del consumidor de la API.

Inyección de dependencias

.NET incorpora un contenedor de dependencias que facilita la creación de aplicaciones desacopladas y fáciles de probar.

Utilizar logging

Registrar eventos mediante ILogger ayuda a detectar errores y monitorear el comportamiento de la aplicación en producción.

Aplicar autenticación JWT

Incluso un CRUD sencillo debería proteger sus operaciones mediante autenticación y autorización para evitar accesos no autorizados.

Crear un CRUD profesional en .NET 10 va mucho más allá de insertar, consultar, actualizar y eliminar registros. Una implementación de calidad debe incorporar arquitectura organizada, Entity Framework Core, validaciones, manejo de errores, programación asíncrona, seguridad y buenas prácticas de desarrollo. Siguiendo estos principios, es posible construir APIs modernas, mantenibles y preparadas para crecer junto con las necesidades del negocio, garantizando un código limpio y una experiencia sólida tanto para desarrolladores como para usuarios finales.

Artículo publicado acerca de: CRUD profesional en .NET 10 con buenas prácticas avanzadas.