Creación de aplicaciones web en C# con ASP.NET Core

Ejecutar la aplicación por defecto

Tim comienza ejecutando la aplicación por defecto para ilustrar lo que los desarrolladores obtienen al sacarla de la caja. Una vez ejecutado, el proyecto crea la API, descarga los paquetes NuGet necesarios y abre una página web. Esta configuración inicial demuestra la estructura básica y las funcionalidades de la API sin ninguna modificación.

Interacción con la API

La página web que se lanza funciona con Swagger, ahora conocido como OpenAPI. Swagger proporciona una interfaz fácil de usar para interactuar con la API. Permite tanto a desarrolladores como a no desarrolladores comprender y probar los puntos finales de la API con facilidad. Esta interfaz es especialmente útil para visualizar el funcionamiento de la API y para fines de documentación.

Explorando Swagger

Swagger muestra los puntos finales disponibles en la API. En la configuración por defecto, uno de los puntos finales preconfigurados es el de "previsión meteorológica". Al hacer clic en este punto final y utilizar la función "Pruébelo", los usuarios pueden ejecutar la llamada a la API y ver la respuesta. Esta respuesta incluye una previsión meteorológica en formato JSON, lo que demuestra cómo se devuelven los datos desde la API.

Tim destaca en el minuto 8:32 que, si bien los datos JSON en bruto pueden ser difíciles de leer directamente desde el navegador, la documentación superpuesta de Swagger los hace mucho más digeribles. La documentación proporciona información detallada sobre el punto final, incluido el método de solicitud (GET, POST, etc.), la estructura de los datos devueltos y los parámetros necesarios.

Documentación JSON y versiones de API

Swagger también genera un archivo JSON, como señala Tim en el minuto 9:10, que documenta la API en un formato legible por máquina. Esta documentación es crucial para otras aplicaciones que necesiten interactuar con la API, ya que describe los puntos finales disponibles, los esquemas de datos y las respuestas esperadas.

Tim, a las 9:29, señala la importancia del control de versiones en las API. La configuración por defecto incluye un indicador de versión, que apunta a la posibilidad de que existan varias versiones de la API. El control de versiones es vital para mantener la compatibilidad con versiones anteriores. Cuando los cambios en la API pueden romper los clientes existentes, tener varias versiones permite a los desarrolladores introducir nuevas características o cambios sin interrumpir a los usuarios actuales.

Propósito de las API

Tim subraya que la mayoría de las aplicaciones giran en torno a la recuperación, manipulación y visualización de datos. Las API actúan como intermediarias entre la interfaz de usuario y los datos subyacentes, proporcionando un medio seguro y eficaz de acceso a los datos. Esta centralización es crucial por varias razones:

1. Seguridad: Las API ofrecen una forma segura de gestionar el acceso a los datos. Las aplicaciones móviles y del lado del cliente no deben conectarse directamente a bases de datos para evitar incrustar credenciales de bases de datos en el código del cliente, lo que plantea importantes riesgos de seguridad.

2. Abstracción: Las API abstraen la capa de datos de la interfaz de usuario, lo que permite que diferentes aplicaciones cliente (aplicaciones móviles, aplicaciones web, aplicaciones de escritorio) interactúen con la misma fuente de datos sin exponer la base de datos o sus credenciales.

Versatilidad en diferentes marcos

Tim señala que las API no se limitan a marcos de trabajo o lenguajes específicos. Por ejemplo, se puede acceder a una API de C# desde frameworks de JavaScript como Angular, React o Vue, lo que demuestra las capacidades multiplataforma de las API.

1. Descripción general de Program.cs

Tim revisa Program.cs, señalando que construye la aplicación web y configura servicios como la inyección de dependencias para controladores y Swagger (OpenAPI). El código configura los servicios esenciales antes de crear y ejecutar la aplicación.

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

2. Configuración del entorno

Tim explica cómo se configuran los ajustes del entorno en launchSettings.json. El entorno predeterminado es "Desarrollo" para las pruebas locales, lo que permite Swagger. En producción, Swagger suele estar desactivado por motivos de seguridad, pero puede activarse eliminando la comprobación de desarrollo.

{
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "WebApplication": {
      "commandName": "Project",
      "launchBrowser": true,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

3. Redirección y controladores HTTPS

Tim destaca la redirección HTTPS y la asignación de controladores. Esta configuración garantiza que las rutas API estén correctamente configuradas. Prefiere utilizar un prefijo "api" para mayor claridad en las rutas HTTP de solicitud y respuesta, que pueden modificarse para garantizar que las rutas API sean distintas.

4. Controlador de previsiones meteorológicas

Tim profundiza en WeatherForecastController.cs, destacando la configuración de rutas. La ruta predeterminada es /weatherforecast, que se puede modificar para incluir un prefijo "api". El controlador utiliza HTTP GET para recuperar datos, a los que se puede acceder a través de la ruta especificada.

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(ILogger<WeatherForecastController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

public class WeatherForecast
{
    public DateTime Date { get; set; }

    public int TemperatureC { get; set; }

    public string? Summary { get; set; }
}

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(ILogger<WeatherForecastController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

public class WeatherForecast
{
    public DateTime Date { get; set; }

    public int TemperatureC { get; set; }

    public string? Summary { get; set; }
}

5. Verbos HTTP y enrutamiento

Tim explica cómo los verbos HTTP (GET, POST, PUT, DELETE) definen los puntos finales de la API. Para una solicitud GET, el navegador llama al método especificado en el controlador. Otros verbos requieren herramientas como Postman para realizar pruebas.

API REST

Tim Corey presenta REST (Representational State Transfer) y sus principios:

1. Qué es REST: REST es un estilo arquitectónico para diseñar aplicaciones en red. Se basa en la comunicación sin estado y utiliza métodos HTTP estándar (GET, POST, PUT, DELETE) para realizar operaciones.

2. Principios RESTful: Las API RESTful utilizan patrones de URL para representar recursos. Por ejemplo, /users recupera todos los usuarios, mientras que /users/5 recupera un usuario específico con ID 5.

3. Cumplimiento de REST: Tim señala que lograr el pleno cumplimiento de REST puede ser un reto, ya que REST fue originalmente un modelo teórico. Sin embargo, la adhesión a los principios REST puede conducir a APIs más intuitivas y coherentes.

Tim hace hincapié en que, aunque el objetivo es el cumplimiento de REST, las consideraciones prácticas deben guiar el diseño de la API para garantizar la facilidad de uso y la funcionalidad.

Aplicación API mínima

Corey presenta Minimal APIs, un enfoque simplificado para el desarrollo de API en ASP.NET Core:

1. Configuración de API mínimas: Tim muestra cómo crear un proyecto de API mínima desmarcando la opción "Usar controladores" al configurar el proyecto.

2. Código simplificado: Las APIs mínimas eliminan la necesidad de controladores y atributos de enrutamiento, permitiendo a los desarrolladores definir puntos de extremo directamente en Program.cs usando métodos como app.MapGet(), app.MapPost(), etc.

3. Ejemplo de código: Tim proporciona un ejemplo de código en el que una sola línea de código define un punto final. Demuestra cómo asignar una solicitud GET a un punto final con una configuración mínima.

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;

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

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

app.Run();

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;

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

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

app.Run();

Las API mínimas están diseñadas para simplificar el desarrollo, especialmente para aplicaciones más pequeñas o microservicios.