Formación corporativa en .NET

.NET es la plataforma de código abierto y multiplataforma de Microsoft para construir aplicaciones de servidor, escritorio, móvil, cloud, IoT, juegos y modelos de ML sobre un runtime único (CoreCLR) y una biblioteca base unificada (BCL). La versión .NET 10 LTS (calendario de Microsoft) consolida C# 14, primary constructors estables, collection expressions, Native AOT con menos restricciones, Minimal APIs avanzadas, gRPC, Kestrel mejorado, el compilador Roslyn, .NET Aspire para orquestación de microservicios, ML.NET 4 y Entity Framework Core 9 como capa de datos.

Arquitectura de .NET

Tres capas componen la plataforma: SDK (compilador Roslyn, MSBuild, plantillas, CLI dotnet), Runtime (CoreCLR con JIT y recolector de basura) y BCL (System.*, librerías base). Sobre ellas se apilan las cargas de trabajo: ASP.NET Core, EF Core, Blazor, MAUI, WPF, WinForms.

graph TB
  subgraph SDK
    A1[Roslyn<br/>compilador C#/F#/VB]
    A2[MSBuild]
    A3[CLI dotnet]
    A4[Plantillas<br/>dotnet new]
  end
  subgraph Runtime
    B1[CoreCLR<br/>loader + JIT]
    B2[Garbage Collector<br/>generacional]
    B3[Tiered Compilation<br/>ReadyToRun]
    B4[Native AOT]
  end
  subgraph BCL[Base Class Library]
    C1[System.*]
    C2[System.Collections]
    C3[System.IO]
    C4[System.Net.Http]
    C5[System.Text.Json]
  end
  subgraph Cargas
    D1[ASP.NET Core]
    D2[EF Core 9]
    D3[Blazor]
    D4[MAUI]
    D5[WPF/WinForms]
    D6[ML.NET 4]
  end
  SDK --> Runtime
  Runtime --> BCL
  BCL --> Cargas

Del código fuente al binario nativo

.NET compila en dos fases: Roslyn transforma el código C# en IL (lenguaje intermedio) que se empaqueta en ensamblados .dll. En ejecución, CoreCLR usa JIT para convertir IL a código nativo (con tiered compilation y ReadyToRun para acelerar el arranque) o, con Native AOT, se genera un binario nativo directamente en tiempo de publicación.

flowchart LR
  src[Código C#<br/>*.cs] --> roslyn[Roslyn<br/>compilador]
  roslyn --> il[IL + metadatos<br/>*.dll]
  il --> jit[JIT en CoreCLR<br/>tiered + R2R]
  jit --> nativo1[Código nativo<br/>en memoria]
  il -.publish AOT.-> aot[ILC<br/>compilador AOT]
  aot --> nativo2[Binario nativo<br/>*.exe sin JIT]

Project files SDK-style

Los proyectos .csproj modernos usan formato SDK-style: un archivo XML breve con Sdk="Microsoft.NET.Sdk", TargetFramework, PackageReference y propiedades opcionales (PublishAot, InvariantGlobalization, ImplicitUsings). Los ficheros se incluyen por convención y no hace falta listarlos.

graph LR
  csproj["MiApi.csproj<br/>&lt;Project Sdk=&quot;Microsoft.NET.Sdk.Web&quot;&gt;"]
  csproj --> tf["TargetFramework<br/>net10.0"]
  csproj --> props["Propiedades<br/>Nullable, ImplicitUsings, PublishAot"]
  csproj --> pkgs["PackageReference<br/>NuGet packages"]
  csproj --> sln[.sln<br/>agrupa proyectos]
  props --> build[dotnet build]
  pkgs --> restore[dotnet restore]
  restore --> build
  build --> bin[bin/Debug/net10.0/<br/>MiApi.dll]

NuGet: gestión de paquetes

NuGet es el gestor de paquetes oficial. El comando dotnet add package registra una PackageReference en el .csproj. dotnet restore descarga paquetes desde las fuentes configuradas en NuGet.config (nuget.org por defecto) a la caché global ~/.nuget/packages y resuelve el grafo de dependencias transitivas.

flowchart LR
  dev["dotnet add package<br/>Serilog.AspNetCore"]
  dev --> csp["MiApi.csproj<br/>PackageReference"]
  csp --> restore[dotnet restore]
  restore --> feeds{"Fuentes<br/>NuGet.config"}
  feeds --> pub[(nuget.org)]
  feeds --> priv[(Feed privado<br/>Azure Artifacts, GitHub)]
  pub --> cache[(Cache global<br/>~/.nuget/packages)]
  priv --> cache
  cache --> build[dotnet build]
  build --> bin[Ensamblados + deps]

Entity Framework Core 9

EF Core 9 es el ORM oficial. Un DbContext agrupa DbSet<T> que representan tablas; las consultas LINQ se traducen a SQL y el cambio de estado se confirma con SaveChangesAsync. Las migraciones (dotnet ef migrations) versionan el esquema.

graph TB
  app[Código aplicación]
  app --> ctx[AppDbContext<br/>: DbContext]
  ctx --> dbset1[DbSet&lt;Usuario&gt;]
  ctx --> dbset2[DbSet&lt;Pedido&gt;]
  dbset1 --> linq[Consultas LINQ]
  dbset2 --> linq
  linq --> translator[Query Translator<br/>LINQ to SQL]
  translator --> sql[SQL parametrizado]
  sql --> provider[Provider<br/>SqlServer / Npgsql / Sqlite]
  provider --> db[(Base de datos)]
  ctx --> ct[Change Tracker]
  ct -.SaveChangesAsync.-> provider

dotnet publish: tres modos de entrega

El comando dotnet publish empaqueta la aplicación para producción. Hay tres modos principales: framework-dependent (requiere runtime instalado), self-contained (incluye el runtime) y Native AOT (binario nativo sin JIT, arranque instantáneo y huella reducida).

flowchart TB
  src[Código + csproj] --> publish["dotnet publish<br/>-c Release"]
  publish --> fd["Framework-dependent<br/>-c Release"]
  publish --> sc["Self-contained<br/>--self-contained -r linux-x64"]
  publish --> aot["Native AOT<br/>PublishAot=true"]
  fd --> fdo["~10 MB<br/>necesita runtime"]
  sc --> sco["~70 MB<br/>runtime embebido"]
  aot --> aoto["~8 MB nativo<br/>arranque &lt; 50 ms<br/>sin reflection dinámica"]

Cross-platform: un SDK, muchas plataformas

.NET 10 soporta Windows, Linux, macOS, iOS y Android desde el mismo SDK. El RID (Runtime Identifier) como linux-x64, win-arm64 u osx-arm64 selecciona el binario nativo en publish. MAUI extiende el alcance a móvil y escritorio con una única base de código.

graph TB
  sdk["SDK único<br/>dotnet 10"]
  sdk --> win["Windows<br/>win-x64, win-arm64"]
  sdk --> lin["Linux<br/>linux-x64, linux-arm64, linux-musl"]
  sdk --> mac["macOS<br/>osx-x64, osx-arm64"]
  sdk --> ios["iOS<br/>ios-arm64 (MAUI)"]
  sdk --> and["Android<br/>android-arm64 (MAUI)"]
  sdk --> web["WebAssembly<br/>browser-wasm (Blazor WASM)"]
  win --> run[dotnet run / publish]
  lin --> run
  mac --> run
  ios --> run
  and --> run
  web --> run

Pipeline de peticiones en ASP.NET Core

Cuando llega una petición, Kestrel la entrega al host que la empuja por la cadena de middleware hasta el enrutador, los filtros y el endpoint. La respuesta regresa por el mismo camino para que cada middleware pueda decorar cabeceras, comprimir o registrar telemetria.

flowchart LR
  cli[Cliente HTTP] --> kestrel[Kestrel<br/>servidor HTTP/2 y HTTP/3]
  kestrel --> host[WebApplication host<br/>DI container y configuración]
  host --> mw1[UseHttpsRedirection]
  mw1 --> mw2[UseRateLimiter]
  mw2 --> mw3[UseAuthentication]
  mw3 --> mw4[UseAuthorization]
  mw4 --> mw5[UseOutputCache]
  mw5 --> routing[UseRouting]
  routing --> endpoints[UseEndpoints]
  endpoints --> filters[Endpoint filters]
  filters --> action[Minimal API o controller]
  action --> ef[EF Core 9<br/>o servicio]
  ef --> action
  action --> filters
  filters --> endpoints
  endpoints --> kestrel
  kestrel --> cli

Minimal APIs maduras vs controllers

ASP.NET Core 10 cierra la brecha funcional entre Minimal APIs y los controllers MVC. Los endpoints mínimos soportan MapGroup, filtros de endpoint, AsParameters para agrupar parámetros, TypedResults con OpenAPI tipado y validación declarativa. Los controllers siguen siendo la elección cuando el equipo necesita convenciones, binding complejo o áreas.

graph LR
  subgraph Minimal["Minimal APIs (maduras)"]
    M1[MapGroup /api]
    M2[AddEndpointFilter]
    M3[AsParameters]
    M4[TypedResults]
    M5[RequireAuthorization]
    M6[WithOpenApi]
  end
  subgraph Controllers["Controllers MVC"]
    C1[ApiController]
    C2[Action filters]
    C3[ModelBinder personalizado]
    C4[IActionResult]
    C5[Áreas y convenciones]
    C6[Swashbuckle o OpenApi]
  end
  D[Handler: Minimal API<br/>con primary constructor<br/>inyecta servicios] --- M1
  E[ControllerBase<br/>con DI por constructor] --- C1
  Minimal --> AOT[Compatible con Native AOT]
  Controllers --> Reflexion[Usa reflexion:<br/>menos amigable con AOT]

Blazor United: un modelo, cuatro estrategias de render

Blazor United unifica Server, WebAssembly, componentes estáticos y modos interactivos por componente dentro de una misma aplicación. Cada componente puede elegir su render mode sin duplicar código ni cambiar de proyecto.

graph TB
  app[Blazor United App] --> static[Static SSR<br/>render servidor inicial]
  app --> server[Interactive Server<br/>circuito SignalR]
  app --> wasm[Interactive WebAssembly<br/>runtime .NET en navegador]
  app --> auto[Interactive Auto<br/>arranca Server, pasa a WASM]
  static --> seo[SEO y TTFB rápido]
  server --> stateful[Estado en servidor<br/>latencia baja si misma región]
  wasm --> offline[Funciona offline<br/>descarga assemblies]
  auto --> mejor[Mejor experiencia percibida]

SignalR, hubs y comunicación en tiempo real

SignalR abstrae transportes (WebSockets, Server-Sent Events, long polling) detrás de un Hub. Los clientes suscriben grupos y el servidor difunde mensajes a todos o a subconjuntos. El escalado horizontal se apoya en un backplane con Redis o Azure SignalR Service.

graph LR
  c1[Cliente A] -->|WebSocket| hub[ChatHub<br/>: Hub]
  c2[Cliente B] -->|WebSocket| hub
  c3[Cliente C] -->|SSE| hub
  hub --> group1[Group: sala-general]
  hub --> group2[Group: sala-privada]
  group1 --> c1
  group1 --> c2
  group2 --> c3
  hub --> backplane[Redis o Azure SignalR<br/>backplane escalado horizontal]
  backplane --> hub2[Instancia 2 del Hub]
  hub2 --> c4[Cliente D]

Identity, JWT y OpenIddict

ASP.NET Core Identity aporta gestión de usuarios, roles y tokens. Para APIs se emiten JWT firmados; para flujos estándar de autorización (OAuth 2.1, OpenID Connect, PKCE) se integra OpenIddict como servidor de autorización dentro de la propia aplicación o en un servicio dedicado.

flowchart TB
  user[Usuario] --> login[POST /auth/login<br/>credenciales]
  login --> identity[ASP.NET Core Identity<br/>UserManager + PasswordHasher]
  identity --> openid[OpenIddict<br/>servidor OAuth 2.1 y OIDC]
  openid --> jwt[JWT firmado<br/>claims: sub, role, scope]
  jwt --> cli[Cliente SPA o movil]
  cli --> api[API protegida<br/>.RequireAuthorization]
  api --> jwtbearer[JwtBearer middleware<br/>valida firma y expiración]
  jwtbearer --> policy[AuthorizationPolicy<br/>por role, scope o claim]
  policy --> endpoint[Endpoint autorizado]

Qué incluye este itinerario

• Plataforma y CLI: arquitectura .NET, runtime, SDK, CLI dotnet new/build/run/test/publish, dotnet watch, dotnet dev-certs, herramientas globales.
• Proyectos y NuGet: project files SDK-style, Central Package Management, feeds públicos y privados.
• Diseno de APIs: Minimal APIs maduras con MapGroup, AsParameters, TypedResults, filtros de endpoint y controllers MVC con filtros y convenciones REST.
• Contratos: model binding, validación, OpenAPI nativo con Microsoft.AspNetCore.OpenApi, convivencia con Swashbuckle y versionado.
• Datos: EF Core 9, migraciones, patrones repositorio y Unit of Work, proyecciones, IQueryable.
• Seguridad: JWT Bearer, cookies, Identity con scaffolding, políticas, CORS, rate limiting y OpenIddict para OAuth 2.1 y OpenID Connect.
• Tiempo real y binario: SignalR con backplane Redis, gRPC con Protobuf optimizado y streaming bidireccional.
• Interfaz servidor y Blazor: Razor Pages, MVC, Razor components reutilizables y Blazor United con render modes Server, WebAssembly, Static SSR e Interactive Auto.
• Caches y estado: output caching, hybrid cache (combinación memoria local mas distribuido), cookies, sesión, TempData.
• Observabilidad y orquestación: BackgroundService, health checks, OpenTelemetry, .NET Aspire para orquestación de microservicios, BenchmarkDotNet, ML.NET 4.
• Entrega: pruebas con WebApplicationFactory, dotnet publish, Native AOT, single-file, Docker multistage, MAUI, proxy inverso.

Público objetivo

• Desarrolladores backend que quieren una visión completa y actual de .NET 10 LTS.
• Perfiles full stack con Razor, MVC o Blazor sobre ASP.NET Core.
• Equipos que construyen microservicios orquestados con Aspire y despliegue en contenedores.
• Profesionales que evalúan Native AOT, single-file o MAUI para escenarios de rendimiento o multiplataforma.

Prerrequisitos

• C# intermedio con async/await. Si necesitas repasar, el curso de C# en CertiDevs cubre la base antes de entrar en .NET.
• Bases de HTTP y SQL.

Objetivos de aprendizaje

Al recorrer este itinerario serás capaz de:

• Explicar la arquitectura de .NET (SDK, runtime CoreCLR, BCL) y la compilación IL + JIT o Native AOT.
• Crear y operar proyectos con la CLI dotnet y ficheros SDK-style.
• Gestionar dependencias NuGet y herramientas globales.
• Diseñar APIs con Minimal APIs y controladores, documentarlas con OpenAPI y versionarlas.
• Modelar datos con EF Core 9, migraciones y patrones habituales.
• Asegurar aplicaciones con JWT, Identity, políticas, CORS y rate limiting.
• Incorporar SignalR, gRPC, Blazor y caché cuando convenga.
• Observar aplicaciones con health checks, logs estructurados, OpenTelemetry y .NET Aspire.
• Probar y publicar con WebApplicationFactory, Docker multistage, Native AOT, single-file y MAUI para multiplataforma.