Fundamentos y Configuración Inicial

1.1. Introducción al paradigma Minimal API

Definición, historia y objetivos

Las Minimal APIs fueron introducidas en .NET 6 (ASP.NET Core 6) con el objetivo de ofrecer una forma más ligera, rápida y concisa de construir APIs HTTP.

• Minimalismo: Buscan reducir la cantidad de código repetitivo (boilerplate code) necesario para crear un endpoint funcional.
• Velocidad: Permiten a los desarrolladores con experiencia en .NET crear APIs de manera significativamente más rápida que el modelo MVC o Razor Pages.
• Rendimiento: Al ser más simples, pueden ofrecer una ligera ventaja de rendimiento en ciertas cargas de trabajo.

Ventajas frente al modelo MVC tradicional

1.2. Preparación del entorno de desarrollo

Para seguir este curso, necesitarás:

1. Instalación del .NET SDK (última versión LTS): Verifica tu versión con dotnet --version en la terminal. Se recomienda .NET 8 o superior.
2. Editor de Código: Visual Studio (completo) o Visual Studio Code (ligero) con la extensión C#.

1.3. El Proyecto Base

Comando dotnet new web

Para crear un proyecto de Minimal API, utiliza la plantilla más simple:

dotnet new web -n MinimalApiCurso
cd MinimalApiCurso

Análisis del archivo Program.cs y el builder de la aplicación

A diferencia de los proyectos antiguos, el archivo Program.cs ahora maneja tres aspectos principales:

1. Construcción del Host: WebApplication.CreateBuilder(args) crea y configura los servicios básicos (servicios de configuración, logging, etc.).
2. Configuración de Servicios (DI): Cualquier servicio se añade al builder.Services (ej. builder.Services.AddDbContext<T>()).
3. Configuración del Pipeline de Middleware: El objeto app configura el flujo de solicitudes (ej. app.UseHttpsRedirection()).
4. Definición de Endpoints: Los endpoints se mapean directamente al objeto app (ej. app.MapGet()).

1.4. El «Hola Mundo» Minimalista

Uso de WebApplication.CreateBuilder() y app.Run()

La estructura de un proyecto Minimal API se resume en estas tres líneas clave:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello Minimal API!");

app.Run();

Primer endpoint con app.MapGet()

El método app.MapGet() toma dos argumentos:

1. La ruta (Route): La URL a la que responderá el endpoint (ej. "/").
2. El Delegado (Handler): Una función lambda que define la lógica que se ejecutará y el valor que se devolverá. La devolución se serializa automáticamente a la respuesta HTTP (cuerpo y código 200 OK).

El siguiente archivo C# muestra el código completo para este primer módulo.

// Usings necesarios para la aplicación de consola y web.
// (Estos se gestionan implícitamente en proyectos .NET modernos, pero se incluyen para claridad).
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

// ====================================================================
// MÓDULO 1: FUNDAMENTOS Y CONFIGURACIÓN INICIAL
// ====================================================================

// 1. CREACIÓN DEL CONSTRUCTOR DE LA APLICACIÓN (Host y Servicios)
// WebApplication.CreateBuilder(args) configura los valores por defecto
// para el logging, la configuración (appsettings.json) y los servicios.
var builder = WebApplication.CreateBuilder(args);

// --- 1.3 Análisis del Proyecto Base: Configuración de Servicios (DI) ---
// Aunque en este módulo no añadimos servicios complejos, aquí es donde irían:
// builder.Services.AddScoped<IServicio, ServicioImplementacion>();
// builder.Services.AddSwaggerGen();
// ...

// 2. CONSTRUCCIÓN DE LA APLICACIÓN (Pipeline de Middleware)
// El método Build() toma todas las configuraciones y servicios y crea la aplicación ejecutable.
var app = builder.Build();

// --- 1.3 Análisis del Proyecto Base: Configuración del Middleware ---
// Aquí es donde se define el orden en que las solicitudes HTTP serán procesadas.
if (app.Environment.IsDevelopment())
{
    // Middleware para manejar excepciones de forma amigable durante el desarrollo.
    app.UseDeveloperExceptionPage();
}
else
{
    // Middleware de producción (por ejemplo, manejo de errores para el cliente final).
    // app.UseExceptionHandler("/Error");
    // app.UseHsts(); // Opcional, para cabeceras HSTS.
}

// --------------------------------------------------------------------
// 1.4 EL "HOLA MUNDO" MINIMALISTA Y MÉTODOS BÁSICOS
// --------------------------------------------------------------------

// Endpoint 1: Ruta raíz ("/") con app.MapGet()
// Este es el ejemplo más simple de un Minimal API.
// Devuelve una cadena de texto que se serializa automáticamente como respuesta HTTP 200 OK.
app.MapGet("/", () => "¡Hola Mundo desde una Minimal API en .NET!");

// Endpoint 2: Un endpoint de prueba simple
// Acceso en /saludo.
app.MapGet("/saludo", () => {
    return new { Mensaje = "Bienvenido al curso de Minimal APIs", Version = "1.0" };
});

// Endpoint 3: Ejemplo con un parámetro de ruta
// El nombre se extrae automáticamente de la URL.
// Acceso en /usuario/Juan
app.MapGet("/usuario/{nombre}", (string nombre) => 
{
    return $"¡Hola, {nombre}! Tu solicitud ha sido procesada.";
});

// 3. EJECUCIÓN DE LA APLICACIÓN
// Inicia el servidor Kestrel y lo pone a la escucha de peticiones HTTP.
app.Run();

// Nota: En .NET moderno, no se necesita una clase Program explícita ni un método Main estático.
// El compilador genera automáticamente este código.