Curso de .NET 10 para tu equipo — Arquitecturas y seguridad

Instalación y configuración del SDK de .NET 10 en Windows, Linux y macOS

Instalación y configuración de Visual Studio 2022 / 2026 (ediciones, workloads, componentes para .NET 10)

Configuración de VS Code con C# Dev Kit, extensiones recomendadas y atajos productivos para backend

Recorrido por la interfaz de Visual Studio orientado a backend: Solution Explorer, configuraciones, perfiles de ejecución

Creación de proyectos y soluciones con plantillas actualizadas a .NET 10 desde el IDE

Uso de la .NET CLI: `dotnet new`, `build`, `run`, `watch`, `test`, `publish`, `user-secrets`, etc.

Primer contacto con las file-based apps: ejecutar una única clase C# sin .csproj ni .sln

Gestión de versiones del SDK con `global.json` y compatibilidad con soluciones existentes

Introducción al nuevo formato de solución .slnx y convivencia con archivos `.sln` clásicos

Configuración de perfiles de ejecución, variables de entorno y `launchSettings.json` para APIs y servicios

Repaso rápido de tipos de valor y referencia, nullability y uso correcto de tipos anulables en APIs

Trabajando con colecciones modernas y LINQ básico aplicado a escenarios típicos de backend

Manejo de excepciones en aplicaciones servidor: buenas prácticas y patrones de error centrados en APIs

Uso efectivo de clases, interfaces, registros y enumeraciones en modelos de dominio sencillos

Introducción al uso de `Span<T>` y `ReadOnlySpan<T>` en escenarios de alto rendimiento

Nuevas capacidades de C# 14: extension members, `field` en propiedades y mejoras en lambdas

Patrones básicos de programación asíncrona con `async`/`await` orientados a I/O de red y base de datos

Manejo de configuración y constantes desde código evitando valores mágicos (options pattern a alto nivel)

Principios básicos de código limpio en C#: nombres, estructura de clases y separación de responsabilidades

Buenas prácticas de organización de namespaces, archivos y carpetas en soluciones de backend

Estructura de un proyecto .NET 10: archivos clave (`csproj`, `Program.cs`, `appsettings.json`, etc.)

Estructura de una solución con múltiples proyectos: API, capa de datos, librerías de dominio, tests

Nuevo formato de soluciones `.slnx`: ventajas, casos de uso y coexistencia con `.sln`

Workloads, frameworks de destino (`net10.0`) y multitargeting cuando conviene soportar varias versiones

Configuración de `csproj`: referencias de proyectos, referencias de paquetes, propiedades comunes

Manejo de entornos (`Development`, `Staging`, `Production`) y configuración por entorno

Uso de secretos de usuario (`dotnet user-secrets`) frente a variables de entorno y Key Vaults en entornos reales

Organización de capas lógicas: API, aplicación, dominio, infraestructura (visión monolito bien estructurado)

Buenas prácticas de nombrado de proyectos y ensamblados para soluciones empresariales

Plantillas personalizadas y repetibles para soluciones internas de la organización

Repaso del pipeline de ASP.NET Core: middlewares, hosting y modelo de ejecución de peticiones

Configuración del host web, Kestrel y bindings de puertos en local y en producción

Registro de servicios y configuración de la Inversión de Dependencias a nivel de aplicación

Configuración centralizada en `Program.cs`: minimal hosting model y organización recomendada

Middleware frecuentes para backend: logging, manejo de errores, compresión, CORS, seguridad básica

Uso de `IOptions` y patrones de configuración fuertemente tipada para servicios y conectores

Diferencia entre aplicaciones MVC, Razor Pages y Minimal APIs (y cuándo elegir cada una)

Introducción a ASP.NET Core Identity (visión general, sin entrar en detalle de UI)

Uso de características clave de ASP.NET Core 10: mejoras en OpenAPI, minimal API y validaciones

Organización de endpoints y separación por módulos/límites funcionales dentro de la API

Creación de una aplicación MVC en .NET 10 y recorrido por su estructura de carpetas

Conceptos de Model, View y Controller en el contexto de aplicaciones empresariales

Binding de modelos, validación con data annotations y mensajes de error reutilizables

Ruteo en MVC: rutas por convención, rutas por atributo y endpoints modernos

Introducción a Razor Pages y diferencias clave con MVC clásico

Uso de Tag Helpers y View Components para reutilizar funcionalidad en la capa de presentación

Inyección de dependencias en vistas y principios para evitar lógica de negocio en las mismas

Renderización parcial, vistas parciales y layouts para vistas de administración internas

Primer vistazo a Blazor Server/WebAssembly como tecnología complementaria (sin profundizar)

Construcción de un pequeño módulo de backoffice interno usando MVC/Razor para gestionar datos

Creación de una API REST en .NET 10 con controllers y endpoints de ejemplo

Minimal APIs en .NET 10: cuándo usarlas, ventajas y limitaciones frente a controllers

Model binding en APIs: cuerpos JSON, querystring, rutas y cabeceras

Validación de entrada: `ModelState`, filtros y validación a través de DTOs

Tipos de respuesta en controladores: `IActionResult`, `ActionResult<T>`, tipos concretos y resultados problem details

Versionado de APIs: estrategias, cabeceras, querystring, rutas y soporte en Swagger

Documentación con Swagger / Swashbuckle: anotaciones, agrupación por versiones y ejemplos

CORS en APIs: configuración segura para frontends internos y externos

Testing básico de endpoints con herramientas como Postman o HTTP REPL

Construcción de una API modularizada por áreas o features, lista para crecer en soluciones empresariales

Introducción a EF Core 10: DbContext, DbSet y ciclo de vida del contexto en aplicaciones web

Enfoque Code First: diseño de entidades, claves primarias, propiedades de navegación y convenciones

Configuración de la cadena de conexión y proveedores habituales (SQL Server, PostgreSQL, etc.)

Migrations: creación, actualización, rollback y buenas prácticas de nomenclatura

Relaciones 1-1, 1-N y N-N con ejemplos típicos de dominio empresarial

Uso básico de LINQ: filtros, proyecciones, ordenaciones, paginación y consultas asíncronas

Carga de datos: eager loading, explicit loading y lazy loading (cuándo está recomendado y cuándo no)

Mapeo de tipos complejos y uso inicial de JSON columns y filtros globales simples

Gestión de transacciones básicas y uso de `SaveChanges` / `SaveChangesAsync` correctamente

Buenas prácticas de EF Core en backend: evitar sobrecargas del contexto, no exponer entidades directamente, etc.

Cuándo EF Core no es suficiente o no es la mejor opción: casos típicos de uso para Dapper

Introducción a Dapper: filosofía micro-ORM y ventajas de rendimiento

Configuración de Dapper en un proyecto .NET 10 junto a EF Core sin conflictos

Ejecución de consultas de lectura con Dapper y mapeo a modelos de lectura (read models)

Ejecución de comandos de escritura y uso de transacciones con Dapper

Acceso a procedimientos almacenados y consultas complejas usando Dapper

Patrones sencillos de separación: EF Core para escritura, Dapper para lectura (sin entrar en CQRS avanzado)

Introducción a proveedores NoSQL habituales (MongoDB, Redis) y cuándo tiene sentido usarlos

Buenas prácticas para encapsular acceso a datos en repositorios y servicios de infraestructura

Estrategias básicas de paginación y filtrado eficientes desde la base de datos

Fuentes de configuración en ASP.NET Core: archivos JSON, variables de entorno, Key Vault, etc.

Estructura recomendada de `appsettings.*.json` por entorno en soluciones empresariales

Introducción al concepto de logging estructurado y ventajas frente a logs de texto plano

Configuración de logging integrado en ASP.NET Core y niveles de log recomendados para backend

Integración básica con Serilog u otro proveedor estructurado (sin entrar aún en observabilidad distribuida)

Registro de errores y excepciones no controladas en APIs y servicios

Uso de Health Checks para supervisar el estado de la aplicación y la conectividad a dependencias

Métricas básicas de aplicación: peticiones, tiempos de respuesta y errores por endpoint

Introducción a la trazabilidad: correlation IDs y seguimiento de peticiones entre servicios

Buenas prácticas para definir qué loguear, dónde y con qué nivel en una solución de backend

Principios básicos de seguridad en APIs: autenticación, autorización y separación de responsabilidades

Introducción a JWT para autenticar clientes y servicios (visión desde el consumidor de un Identity Provider)

Autorización basada en roles y políticas en ASP.NET Core (RBAC básico)

Protección de endpoints sensibles y gestión de usuarios internos vs externos

Protección frente a vulnerabilidades comunes: XSS, CSRF, SQL Injection (a nivel de framework y buenas prácticas)

Configuración de HTTPS, certificados de desarrollo y consideraciones de HSTS

Cifrado de datos sensibles en configuración y bases de datos (visión conceptual)

Seguridad en CORS, cabeceras de seguridad y límites de tamaño de peticiones/respuestas

Gestión segura de secretos en desarrollo y producción (User Secrets, Key Vault, variables de entorno)

Checklist básico de seguridad para aplicaciones backend en .NET 10 antes de pasar a producción

Fundamentos de contenerización: imágenes, contenedores y registros de contenedores

Creación de un Dockerfile optimizado para ASP.NET Core 10 (multi-stage build, imágenes base recomendadas)

Configuración de variables de entorno, puertos y health checks en contenedores .NET 10

Ejecución local de APIs .NET 10 en contenedores y comunicación con bases de datos externas

Introducción a Docker Compose para levantar API + base de datos en un entorno de desarrollo

Buenas prácticas de logging y almacenamiento de ficheros en entornos dockerizados

Conceptos básicos de despliegue en Azure Web Apps y contenedores en Azure Container Apps

Publicación de imágenes en registros privados (Azure Container Registry, GitHub Container Registry, etc.)

Gestión de configuraciones por entorno en contenedores (config files vs environment variables)

Consideraciones de rendimiento y seguridad básicas al desplegar .NET 10 en contenedores

Tipos de pruebas: unitarias, de integración y de contrato (visión general)

Configuración mínima de un proyecto de pruebas con xUnit o NUnit para soluciones .NET 10

Pruebas unitarias sobre servicios de dominio y servicios de aplicación con dobles de prueba simples

Introducción a pruebas de integración sobre Web APIs con `WebApplicationFactory` y TestServer

Uso de bases de datos en memoria o contenedores de test para probar EF Core

Medición básica de cobertura de código y umbrales razonables en proyectos backend

Análisis estático de código: herramientas recomendadas y reglas mínimas para proyectos serios

Revisión de código, convenciones internas y guías de estilo para equipos .NET

Integración de pruebas en el flujo `dotnet test` y automatización local

Checklist rápido de calidad antes del despliegue: logs, validaciones, manejo de errores, tests críticos

Histórico de versiones de .NET y diferencias conceptuales clave (Framework vs Core vs .NET moderno)

Estrategias de migración desde .NET Core 3.1 / 5 / 6 / 7 / 8 / 9 hacia .NET 10

Revisión de breaking changes habituales y uso de herramientas de análisis de compatibilidad

Planificación de migraciones: fases, entornos, pruebas de regresión y rollback

Actualización de paquetes NuGet y evaluación de compatibilidad con .NET 10

Revisión de dependencias externas y librerías internas no actualizadas

Limpieza y simplificación de soluciones durante la migración (eliminar código muerto y tecnológicas obsoletas)

Aprovechar la migración para introducir mejoras de arquitectura y observabilidad

Documentación de la migración y comunicación con negocio y otros equipos

Estrategia de mantenimiento a largo plazo en una base de código .NET 10 LTS

Definición del problema de negocio y modelado funcional de la solución (dominio sencillo pero realista)

Diseño de la solución monolítica modular: proyectos, capas y responsabilidades

Implementación de la API REST con ASP.NET Core 10 usando buenas prácticas vistas en el curso

Implementación de la capa de datos con EF Core 10 y parte de la lectura optimizada con Dapper

Añadido de validaciones, paginación, filtrado y ordenaciones en endpoints clave

Añadido de logging estructurado, health checks y métricas básicas de la aplicación

Incorporación de autenticación basada en JWT y autorización por roles/políticas

Dockerización de la solución y ejecución local en contenedores con base de datos

Batería mínima de pruebas unitarias e integración sobre la API final

Revisión conjunta: puntos de mejora, posibles extensiones y siguiente paso lógico hacia el curso avanzado