> For the complete documentation index, see [llms.txt](https://elguerre.gitbook.io/de0an/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://elguerre.gitbook.io/de0an/capitulo-11-backstage-y-un-futuro-prometedor/datos-y-backend-moderno.md).

# Datos y Backend Moderno

El capítulo 7 fue donde nuestra aplicación empezó a trabajar con datos reales. Diseñamos el modelo de datos, creamos los servicios de acceso, implementamos las entidades de negocio y configuramos el tratamiento de errores. Era el corazón invisible de Task\[in]: lo que el usuario no ve, pero sin lo cual nada funciona.

Hoy, la forma de construir un backend ha evolucionado significativamente, pero los principios fundamentales permanecen.

## De Azure Mobile Services a .NET Minimal APIs

En el capítulo 7 utilizamos Azure Mobile Services como backend. Era una solución rápida y cómoda para aplicaciones móviles, pero limitada en flexibilidad.

Hoy, **.NET Minimal APIs** ofrece una alternativa mucho más potente y flexible:

```csharp
var app = WebApplication.Create(args);

app.MapGet("/api/proyectos", async (TaskInDbContext db) =>
    await db.Proyectos.ToListAsync());

app.MapGet("/api/proyectos/{id}", async (int id, TaskInDbContext db) =>
    await db.Proyectos.FindAsync(id));

app.MapPost("/api/proyectos", async (Proyecto proyecto, TaskInDbContext db) =>
{
    db.Proyectos.Add(proyecto);
    await db.SaveChangesAsync();
    return Results.Created($"/api/proyectos/{proyecto.Id}", proyecto);
});

app.Run();
```

Pocas líneas, mucha potencia. Y si necesitas más estructura, puedes organizar los endpoints en clases usando **Vertical Slice Architecture** o el patrón **Carter/Minimal API Groups**.

## Entity Framework Core

Entity Framework Core ha madurado enormemente. Es el ORM de referencia en .NET y ofrece:

* **Migraciones**: versionado del esquema de base de datos como código.
* **LINQ**: consultas tipadas y compiladas.
* **Múltiples proveedores**: PostgreSQL, SQL Server, SQLite, CosmosDB y más.
* **Interceptors**: lógica transversal (auditoría, soft delete) sin ensuciar las entidades.

La configuración con Aspire hace que conectar a una base de datos sea trivial:

```csharp
// En el proyecto Aspire Host
var postgres = builder.AddPostgres("db").AddDatabase("taskin");

// En el proyecto API
builder.AddNpgsqlDbContext<TaskInDbContext>("taskin");
```

Aspire se encarga de la cadena de conexión, la resolución de nombres y la inyección de dependencias. Sin archivos de configuración manuales.

## Modelo de datos: la misma disciplina, diferentes herramientas

Las entidades de negocio que definimos en el capítulo 7 — Proyecto, Tarea, Pomodoro, Checklist — siguen siendo la base. Lo que cambia es cómo las modelamos:

```csharp
public class Proyecto
{
    public int Id { get; set; }
    public required string Nombre { get; set; }
    public string? Descripcion { get; set; }
    public string? ImagenUrl { get; set; }
    public DateTime FechaCreacion { get; set; } = DateTime.UtcNow;
    public List<Tarea> Tareas { get; set; } = [];
}

public class Tarea
{
    public int Id { get; set; }
    public required string Titulo { get; set; }
    public bool Completada { get; set; }
    public Prioridad Prioridad { get; set; }
    public int ProyectoId { get; set; }
    public List<Pomodoro> Pomodoros { get; set; } = [];
    public List<ChecklistItem> Checklist { get; set; } = [];
}
```

C# moderno (con `required`, init-only properties, collection expressions) hace que el código sea más conciso y expresivo.

## Aspire integrations para servicios

Donde antes configurábamos cada servicio manualmente, Aspire ofrece **integrations** para los servicios más comunes:

| Servicio              | Aspire Integration                  |
| --------------------- | ----------------------------------- |
| PostgreSQL            | `Aspire.Npgsql.EntityFrameworkCore` |
| Redis (cache)         | `Aspire.StackExchange.Redis`        |
| Azure Blob Storage    | `Aspire.Azure.Storage.Blobs`        |
| RabbitMQ (mensajería) | `Aspire.RabbitMQ.Client`            |
| Azure Service Bus     | `Aspire.Azure.Messaging.ServiceBus` |

Cada integration configura automáticamente health checks, telemetría y resiliencia.

## El rol de la IA en el backend

La IA es particularmente útil para:

* **Generar endpoints CRUD** a partir de las entidades.
* **Crear migraciones** y resolver conflictos de esquema.
* **Escribir consultas LINQ** complejas.
* **Implementar patrones** como CQRS, Repository o Unit of Work.
* **Configurar autenticación** con Identity o JWT.

Pero cuidado con las consultas generadas: siempre verifica el SQL que producen (Entity Framework tiene un excelente logging para esto) y asegúrate de que los índices adecuados están en su sitio.

## La lección que permanece

El acceso a datos es la columna vertebral de cualquier aplicación. Da igual que uses Azure Mobile Services, Minimal APIs o la siguiente tecnología que aparezca: un modelo de datos bien diseñado, servicios con responsabilidades claras y un tratamiento de errores robusto son la base sobre la que se construye todo lo demás.