Programando en C# no. 15: ASP .NET Core

Recordemos lo que es .NET:

".NET es una plataforma de desarrollo gratuita, multiplataforma y de código abierto para crear diversos tipos de aplicaciones".

"Con .NET, puedes usar múltiples lenguajes, editores y bibliotecas para desarrollar aplicaciones web, móviles, de escritorio, juegos, IoT y mucho más".

En entregas pasadas vimos una comparativa entre Spring Boot y ASP .NET Core. Ahora veremos cómo crear una aplicación sencilla usando ésta tecnología.

Nos enfocaremos en las API mínimas para ASP.NET Core.

Las API mínimas son un enfoque simplificado para crear API HTTP rápidas con ASP.NET Core.

Puedes crear endpoints REST completamente funcionales con un mínimo de código y configuración. Evita el uso de la estructura tradicional y los controladores innecesarios declarando de forma fluida las rutas y acciones de la API.

API mínima en ASP .NET Core

Las API mínimas están diseñadas para crear API HTTP con dependencias mínimas. Son ideales para microservicios y aplicaciones que desean incluir solo los archivos, las características y las dependencias mínimas en ASP .NET Core.

Ventajas de ASP .NET Core:

• Serialización sencilla: ASP.NET se diseñó para experiencias web modernas. Los puntos de conexión serializan automáticamente las clases en JSON con el formato correcto de serie. No se necesita ninguna configuración especial. Puede personalizar la serialización para los puntos de conexión que tienen requisitos únicos. 
• Autenticación y autorización: para la seguridad, los puntos de conexión de API tienen compatibilidad integrada con tokens web JSON (JWT) estándar del sector. La autorización basada en directivas ofrece la flexibilidad necesaria para definir reglas de control de acceso eficaces en el código. 
• Enrutamiento junto con el código: ASP.NET permite definir rutas y verbos alineados con el código mediante atributos. Los datos de la ruta de acceso de la solicitud, la cadena de consulta y el cuerpo de la solicitud se enlazan automáticamente a parámetros de método. 
• HTTPS de forma predeterminada: HTTPS es una parte importante de las API web modernas y profesionales. Se basa en el cifrado de un extremo a otro para proporcionar privacidad y ayudar a garantizar que las llamadas API no se intercepten ni se modifiquen entre el cliente y el servidor.

Creando una minimal API con .NET

1. Abrimos una terminal y tecleamos:

$ dotnet --version
$ dotnet --list-sdks

Con esto obtenemos la versión de ``dotnet`` y los SDKs instalados.

2. Creamos un sencillo proyecto webapi:

$ dotnet new webapi -o MyApiSimple
$ cd MyApiSimple

Esto creará el proyecto tipo webapi y nos ubicará en el directorio principal del proyecto.

3. Modificamos el contenido del programa principal para que tenga solo lo necesario.

Program.cs

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

app.MapGet("/hola",()=> Results.Ok("alive"));

app.Run();

4. Modificamos el archivo ``MyApiSimple.http``:

@MyApiSimple_HostAddress = http://localhost:5058

GET {{MyApiSimple_HostAddress}}/hola/
Accept: application/json

###

El archivo de configuración ``MyApiSimple.csproj`` lucirá así:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.1" />
  </ItemGroup>

</Project>

5. Construimos y ejecutamos:

$ dotnet build
$ dotnet run

Abrimos un navegador en la ruta: http://localhost:5058/hola

Si todo va bien, entonces mostrará el siguiente mensaje:

alive

Continuemos.

Consumiendo una API

Lo siguiente a realizar es consumir una API externa. En este caso la del sitio: https://api.chucknorris.io/

Será una aplicación modular por lo que nuestro proyecto lucirá de esta manera:

MyApiSimple/
│
├── Program.cs
├── Services/
│   └── ChuckService.cs
├── Models/
│   └── ChuckJoke.cs

1. Crearemos una clase sencilla en el directorio Models:

ChuckJoke.cs

namespace MyApiSimple.Models
{
    public class ChuckJoke
    {
        public string? value { get; set; }
    }
}

Esta clase representa la respuesta JSON de la API.

2. Ahora crearemos la clase tipo service en el directorio Services:

ChuckService.cs

using System.Text.Json;
using MyApiSimple.Models;

namespace MyApiSimple.Services
{
    public class ChuckService
    {
        private readonly HttpClient _httpClient;

        public ChuckService(HttpClient httpClient)
        {
            _httpClient = httpClient;
        }

        public async Task<ChuckJoke?> GetRandomJokeAsync()
        {
            var url = "https://api.chucknorris.io/jokes/random?category=food";

            var response = await _httpClient.GetAsync(url);

            if (!response.IsSuccessStatusCode)
            {
                return null;
            }

            var content = await response.Content.ReadAsStringAsync();

            return JsonSerializer.Deserialize<ChuckJoke>(content);
        }
    }
}

Esta clase tipo service nos ayudará a encapsular la llamada HTTP.

3. Modificamos la clase principal, registrando el servicio y definiendo los endpoints:

Program.cs

using MyApiSimple.Services;

var builder = WebApplication.CreateBuilder(args);


builder.Services.AddHttpClient<ChuckService>();

var app = builder.Build();

app.MapGet("/hola", () => Results.Ok("alive"));


app.MapGet("/joke", async (ChuckService chuckService) =>
{
    var joke = await chuckService.GetRandomJokeAsync();

    if (joke == null)
    {
        return Results.Problem("Error al obtener el chiste");
    }

    return Results.Ok(joke);
});

app.Run();

4. Modificamos el archivo ``MyApiSimple.http``:

@MyApiSimple_HostAddress = http://localhost:5058

GET {{MyApiSimple_HostAddress}}/hola/
Accept: application/json


GET {{MyApiSimple_HostAddress}}/joke
Accept: application/json

###

5. Construimos y ejecutamos:

$ dotnet build
$ dotnet run

Abrimos un navegador en la ruta: http://localhost:5058/joke

Si todo va bien, entonces mostrará algún mensaje (aleatorio):

{
"value": "Most tough men eat nails for breakfast. Chuck Norris does all of his grocery shopping at Home Depot."
}

Agregaremos Swagger.

6. Modificamos el programa ``Program.cs``:

using MyApiSimple.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpClient<ChuckService>();
builder.Services.AddOpenApi(); 

var app = builder.Build();


if (app.Environment.IsDevelopment())
{
    app.MapOpenApi(); 
}

app.MapGet("/hola", () => Results.Ok("alive"))
   .WithName("Hola")
   .WithOpenApi();

app.MapGet("/joke", async (ChuckService chuckService) =>
{
    var joke = await chuckService.GetRandomJokeAsync();

    if (joke == null)
    {
        return Results.Problem("Error al obtener el chiste");
    }

    return Results.Ok(joke);
})
.WithName("GetJoke")
.WithOpenApi();

app.Run();

7. Construimos y ejecutamos:

$ dotnet build
$ dotnet run

Abrimos un navegador en la ruta: http://localhost:5058/openapi/v1.json

Esto es para ver el OpenAPI JSON, cuya salida será:

{
"openapi": "3.1.1",
"info": {
"title": "MyApiSimple | v1",
"version": "1.0.0"
},
"servers": [
{
"url": "http://localhost:5058/"
}
],
"paths": {
"/hola": {
"get": {
"tags": [
"MyApiSimple"
],
"operationId": "Hola",
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/joke": {
"get": {
"tags": [
"MyApiSimple"
],
"operationId": "GetJoke",
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"tags": [
{
"name": "MyApiSimple"
}
]
}

8. Agregar Swagger UI:

$ dotnet add package Swashbuckle.AspNetCore

9. Modificaremos el programa principal:

Program.cs

using MyApiSimple.Services;

var builder = WebApplication.CreateBuilder(args);


builder.Services.AddHttpClient<ChuckService>();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();


if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.MapGet("/hola", () => Results.Ok("alive"))
   .WithName("Hola");

app.MapGet("/joke", async (ChuckService chuckService) =>
{
    var joke = await chuckService.GetRandomJokeAsync();

    return joke is not null 
        ? Results.Ok(joke)
        : Results.Problem("Error al obtener el chiste");
})
.WithName("GetJoke");

app.Run();

10. Construimos y ejecutamos:

$ dotnet build
$ dotnet run

Si todo va bien, abrimos el navegador en la ruta: http://localhost:5058/swagger

Lucirá de esta manera:

¡Hemos creado un proyecto WebApi con ASP .NET Core!

Continuaremos en próximas entregas hablando de este tema.

Enlaces:

https://codemonkeyjunior.blogspot.com/2019/05/crear-una-aplicacion-web-con-asp-net.html
https://codemonkeyjunior.blogspot.com/2025/11/el-roadmap-para-ser-desarrollador-c.html
https://codemonkeyjunior.blogspot.com/2025/11/asp-net-core-vs-spring-boot-cual-elegir.html
https://codemonkeyjunior.blogspot.com/2025/11/programando-en-c-no-12-asp-net-core.html
https://codemonkeyjunior.blogspot.com/2025/12/equivalencias-entre-un-proyecto-spring.html
https://dotnet.microsoft.com/en-us/learn/back-end-web-dev
https://www.ibm.com/mx-es/think/topics/api-endpoint
https://www.arsys.es/blog/guia-completa-para-el-diseno-de-restful-api-conceptos-y-mejores-practicas
https://robertdelwood.medium.com/learning-api-documentation-with-chuck-norris-jokes-1414435fb84e