Esta lección marca el inicio del recorrido arquitectónico del curso. En lugar de comenzar con teoría abstracta, partiremos de la realidad de la Deuda Técnica inevitable y el problema más común en los sistemas reales: la arquitectura accidental y sus costosas consecuencias.

Analizaremos una aplicación funcional desarrollada en C# que, aunque cumple con los requerimientos, carece de una estructura clara y sostenible. A través de este análisis identificaremos problemas habituales como el acoplamiento fuerte, la mezcla de responsabilidades, la dependencia directa de la infraestructura y la dificultad para escribir pruebas automatizadas.

Esta solución será el punto de partida del curso y se convertirá en nuestro proyecto de referencia. A lo largo de las siguientes lecciones, iremos evolucionándola paso a paso, aplicando principios y enfoques arquitectónicos hasta transformarla en una arquitectura limpia, mantenible y profesional.

En esta lección abordaremos el principio que da origen a la Arquitectura Limpia: el Principio de Inversión de Dependencias (DIP). Analizaremos el DIP no solo como parte de SOLID, sino como el principio que explica el origen de muchos problemas arquitectónicos y constituye la base de sus soluciones.

A partir de la aplicación analizada en la lección anterior, identificaremos cómo las dependencias directas hacia detalles técnicos (bases de datos, frameworks, servicios externos) afectan la estabilidad, la mantenibilidad y la capacidad de evolución del sistema. Veremos por qué el acoplamiento a la infraestructura es uno de los principales obstáculos para construir software sostenible.

Introduciremos el concepto de abstracciones como mecanismo para invertir dependencias y desacoplar el núcleo del sistema de sus detalles de implementación. Aplicaremos estos conceptos directamente sobre el código existente, realizando las primeras refactorizaciones conscientes orientadas a separar reglas de negocio de aspectos técnicos.

Al finalizar esta lección, el participante comprenderá el DIP no solo como parte de SOLID, sino como el fundamento que permite que arquitecturas como Hexagonal, Onion y Clean puedan existir y aportar valor real en aplicaciones .NET.

En esta lección introduciremos la Arquitectura Hexagonal como el mecanismo principal que permite aplicar de forma efectiva la Inversión de Dependencias mediante puertos y adaptadores. Analizaremos el diagrama de la Arquitectura Hexagonal, entendiendo por qué se le conoce como “Ports and Adapters”.

A partir del sistema que hemos venido evolucionando, identificaremos los límites del núcleo de la aplicación y definiremos explícitamente los puertos que representan las necesidades del dominio y los casos de uso. Posteriormente, implementaremos adaptadores que conectan ese núcleo con detalles externos como bases de datos, frameworks web o servicios de infraestructura, sin comprometer su independencia.

Analizaremos el flujo de control característico de la Arquitectura Hexagonal, entendiendo cómo las dependencias se invierten y cómo el núcleo permanece ajeno a los mecanismos técnicos. Aplicaremos estos conceptos directamente sobre la solución existente, introduciendo por primera vez una separación clara entre lógica de negocio y detalles de infraestructura.

Al finalizar esta lección, el participante será capaz de identificar, diseñar e implementar puertos y adaptadores en aplicaciones .NET, comprendiendo cómo Hexagonal Architecture hace tangible la inversión de dependencias y sienta las bases para una arquitectura limpia, flexible y evolutiva.

En esta lección presentaremos Onion Architecture como una forma clara y natural de estructurar una aplicación .NET a partir de los principios y mecanismos ya estudiados. Veremos Onion Architecture como una organización estructural de capas concéntricas (la cebolla) que refleja de manera explícita la Inversión de Dependencias y la centralidad absoluta del Dominio como el núcleo inmutable del sistema.

A partir de la arquitectura Hexagonal implementada en la lección anterior, reorganizaremos la solución en capas bien definidas. Analizaremos el rol de cada capa, sus responsabilidades y, crucialmente, la Regla de Dependencia: cómo las referencias solo pueden apuntar hacia las capas internas, asegurando que los cambios externos no afecten al núcleo.

Traduciremos estos conceptos a una estructura concreta de proyectos y referencias en .NET, entendiendo por qué esta organización resulta especialmente natural en el ecosistema .NET. Veremos cómo los puertos definidos previamente encajan dentro de esta nueva estructura y cómo los adaptadores de infraestructura se ubican en las capas más externas sin comprometer el núcleo.

Al finalizar esta lección, el participante comprenderá cómo utilizar Onion Architecture como un modelo estructural para aplicaciones .NET.

En esta lección finalizaremos la evolución arquitectónica introduciendo Clean Architecture. Propuesta por Robert C. Martin ("Uncle Bob"), veremos que Clean Architecture no es una arquitectura nueva, sino una síntesis magistral de Hexagonal y Onion, que añade un enfoque crítico en la orquestación de la lógica de aplicación.

Analizaremos el diagrama de Clean Architecture con sus cuatro anillos, identificando la relación y las diferencias clave con la estructura Onion ya implementada.

El foco principal de esta lección será el rol del Caso de Uso (Use Case / Interactor). Entenderemos cómo el Caso de Uso actúa como el único orquestador de la aplicación, definiendo el flujo de datos y manipulando las entidades del dominio para cumplir con un requisito funcional específico.

Implementaremos la estructura de los Casos de Uso, incluyendo la definición de DTOs (Data Transfer Objects) de entrada y salida, asegurando que la lógica de aplicación se mantenga completamente aislada de los adaptadores de infraestructura y de presentación.

Al finalizar esta lección, el participante dominará Clean Architecture como el conjunto de principios que guían el diseño de sistemas verdaderamente mantenibles y evolutivos. Contará con un marco de trabajo claro para evaluar y refactorizar la arquitectura de cualquier aplicación .NET real, y estará listo para aplicar los patrones de modelado avanzado de Domain-Driven Design (DDD) en la capa de Dominio.

En esta lección presentaremos Vertical Slice Architecture como una estrategia de organización del código orientada a funcionalidades, no a capas técnicas. Veremos cómo este enfoque permite trabajar sobre una arquitectura limpia ya establecida, mejorando la claridad, la escalabilidad y la evolución del sistema a medida que crece.

A partir de la solución estructurada con Clean Architecture, Hexagonal, Onion y DDD, reorganizaremos la aplicación por casos de uso o Features. Agruparemos en un mismo lugar todo lo necesario para una funcionalidad específica, desde el controlador hasta la persistencia. Analizaremos cómo este enfoque reduce drásticamente el acoplamiento accidental entre funcionalidades y facilita que un desarrollador pueda abordar una Feature completa sin tener que saltar entre múltiples proyectos y carpetas.

Estudiaremos cómo Vertical Slice Architecture convive naturalmente con los principios ya aplicados, sin violar las reglas de dependencia ni comprometer el dominio. Veremos patrones comunes como la segregación de responsabilidades mediante Comandos (para modificar el estado) y Consultas (para leer datos), y cómo cada slice puede evolucionar, probarse y desplegarse de forma más independiente dentro de una misma solución.

Al finalizar esta lección, el participante comprenderá cómo aplicar VSA para organizar la complejidad de una aplicación Clean/Onion a medida que escala, logrando un código más mantenible, enfocado y eficiente para el equipo de desarrollo. Con esto, habrá completado la transformación del sistema, dominando el ciclo completo que va desde los principios de diseño (DIP) hasta la organización del código moderno (VSA), sentando una base sólida para el desarrollo de software empresarial duradero y de alta calidad en .NET.