Arquitectura de Software con C# 12: Infraestructura – Implementación de Persistencia y Controladores en Clean Architecture con DDD

Introducción a la clase

Hemos aprendido cómo desacoplar la lógica de negocio usando interfaces e inversión de dependencias. Ahora veremos cómo implementar la persistencia de datos y los controladores en Clean Architecture con DDD.

En esta clase, aprenderemos a:

• Implementar la persistencia de datos en la Capa de Infraestructura.
• Configurar Entity Framework Core (EF Core) en un proyecto basado en Clean Architecture.
• Crear un Controlador REST API que use nuestros Casos de Uso.
• Aplicar buenas prácticas para evitar acoplamientos innecesarios.

¿Qué obtendrás de esta clase?

• Aprenderás a integrar bases de datos en Clean Architecture.
• Implementarás un Repositorio con Entity Framework Core.
• Crearás un controlador en ASP.NET Core que usará Casos de Uso.
• Conocerás buenas prácticas en la Infraestructura de Clean Architecture.

Paso 1: Configurar Entity Framework Core en .NET

Para almacenar nuestros datos en una base de datos SQL Server o SQLite, usaremos Entity Framework Core (EF Core).

Instalar Entity Framework Core en el proyecto

Ejecuta el siguiente comando en la terminal de .NET CLI dentro del proyecto:

dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Design

Si usas SQLite:

dotnet add package Microsoft.EntityFrameworkCore.Sqlite

Paso 2: Configurar el DbContext en la Capa de Infraestructura

El DbContext se encargará de administrar la conexión con la base de datos y el mapeo de nuestras entidades.

Crear la clase AppDbContext en la Capa de Infraestructura:

public class AppDbContext : DbContext
{
    public DbSet<Pedido> Pedidos { get; set; }

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Pedido>().HasKey(p => p.Id);
    }
}

Paso 3: Implementar un Repositorio con Entity Framework Core

En la clase anterior definimos la interfaz IPedidoRepository en la Capa de Aplicación. Ahora la implementamos en la Capa de Infraestructura usando EF Core.

public class PedidoRepository : IPedidoRepository
{
    private readonly AppDbContext _context;

    public PedidoRepository(AppDbContext context)
    {
        _context = context;
    }

    public void Guardar(Pedido pedido)
    {
        _context.Pedidos.Add(pedido);
        _context.SaveChanges();
    }

    public Pedido ObtenerPorId(int id)
    {
        return _context.Pedidos.FirstOrDefault(p => p.Id == id);
    }
}

Beneficios de este enfoque:

• Separamos la lógica de negocio de la persistencia.
• Podemos cambiar la base de datos sin afectar la Aplicación.
• Es fácil de probar y extender.

Paso 4: Configurar la Base de Datos en ASP.NET Core

Para que .NET Core utilice nuestro DbContext, lo registramos en Program.cs:

var builder = WebApplication.CreateBuilder(args);

// Configurar Entity Framework Core con SQL Server
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// Configurar inyección de dependencias
builder.Services.AddScoped<IPedidoRepository, PedidoRepository>();
builder.Services.AddScoped<CrearPedidoUseCase>();

var app = builder.Build();

Configurar la conexión a la base de datos en appsettings.json:

"ConnectionStrings": {
  "DefaultConnection": "Server=localhost;Database=PedidosDb;Trusted_Connection=True;"
}

Paso 5: Crear y Aplicar Migraciones de Base de Datos

Para crear la base de datos en SQL Server con EF Core, ejecuta:

dotnet ef migrations add InitialCreate
dotnet ef database update

Esto creará una tabla Pedidos en la base de datos.

Paso 6: Crear un Controlador REST en ASP.NET Core

Para exponer nuestra lógica a través de una API, creamos un Controlador en la Capa de Presentación.

[ApiController]
[Route("api/pedidos")]
public class PedidoController : ControllerBase
{
    private readonly CrearPedidoUseCase _crearPedidoUseCase;
    private readonly IPedidoRepository _pedidoRepository;

    public PedidoController(CrearPedidoUseCase crearPedidoUseCase, IPedidoRepository pedidoRepository)
    {
        _crearPedidoUseCase = crearPedidoUseCase;
        _pedidoRepository = pedidoRepository;
    }

    [HttpPost]
    public IActionResult CrearPedido([FromBody] Pedido pedido)
    {
        _crearPedidoUseCase.Ejecutar(pedido);
        return Ok("Pedido creado exitosamente");
    }

    [HttpGet("{id}")]
    public IActionResult ObtenerPedido(int id)
    {
        var pedido = _pedidoRepository.ObtenerPorId(id);
        if (pedido == null)
            return NotFound();

        return Ok(pedido);
    }
}

Explicación del código:

• CrearPedido() → Usa el Caso de Uso para crear un pedido.
• ObtenerPedido() → Recupera un pedido desde el repositorio.
• La API sigue principios REST y es independiente del dominio.

Errores comunes al implementar la infraestructura en Clean Architecture

• Acceder directamente a la base de datos desde los Casos de Uso.
  Solución: Usar repositorios para encapsular la persistencia.
• No usar inyección de dependencias.
  Solución: Registrar correctamente las dependencias en Program.cs.
• No manejar excepciones en los controladores.
  Solución: Usar try-catch o middleware para manejar errores globalmente.

Prueba de la API REST con Postman o cURL

Para probar la API, ejecuta el servidor con:

dotnet run

Luego, usa Postman o cURL para enviar una solicitud:

Crear un Pedido (POST)

POST http://localhost:5000/api/pedidos
Content-Type: application/json

{
  "id": 1,
  "cliente": "Juan Pérez"
}

Obtener un Pedido (GET)

GET http://localhost:5000/api/pedidos/1

Cuestionario de Autoevaluación

• ¿Por qué usamos un DbContext en la Capa de Infraestructura?
• ¿Cómo nos ayuda la inyección de dependencias en la configuración de la base de datos?
• ¿Por qué los Casos de Uso no deben interactuar directamente con la base de datos?
• ¿Cuál es el propósito del Controlador en la Capa de Presentación?
• ¿Cómo probarías la API sin necesidad de una base de datos real?

Resumen de la Clase

• Entity Framework Core nos permite gestionar la persistencia en Clean Architecture.
• Los Repositorios encapsulan la lógica de acceso a datos y exponen interfaces en la Capa de Aplicación.
• Los Controladores en ASP.NET Core manejan las solicitudes de la API REST y delegan la lógica a los Casos de Uso.
• Las dependencias deben ser registradas en Program.cs para que el contenedor de .NET las resuelva automáticamente.

Próximo paso

En la siguiente clase veremos un caso práctico completo con Clean Architecture, DDD y una API REST funcional en C#.