Elección entre las API basadas en controlador y las API mínimas

ASP.NET Core admite dos enfoques para crear API: un enfoque basado en controlador y API mínimas. Los controladores de un proyecto API son clases que se derivan de ControllerBase. Las API mínimas definen puntos de conexión con controladores lógicos en lambdas o métodos. En este artículo se señalan las diferencias entre los dos enfoques.

El diseño de las API mínimas oculta la clase host de forma predeterminada y se centra en la configuración y la extensibilidad a través de métodos de extensión que toman funciones como expresiones lambda. Los controladores son clases que pueden tomar dependencias a través de la inserción de constructores o la inserción de propiedades y, por lo general, siguen patrones orientados a objetos. Las API mínimas admiten la inserción de dependencias a través de otros enfoques, como el acceso al proveedor de servicios.

Este es el código de ejemplo de una API basada en controladores:

namespace APIWithControllers;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        builder.Services.AddControllers();
        var app = builder.Build();

        app.UseHttpsRedirection();

        app.MapControllers();

        app.Run();
    }
}

using Microsoft.AspNetCore.Mvc;

namespace APIWithControllers.Controllers;
[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(Name = "GetWeatherForecast")]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

El código siguiente proporciona la misma funcionalidad en un proyecto de API mínima. Observe que el enfoque de API mínima implica incluir el código relacionado en expresiones lambda.

namespace MinimalAPI;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        var app = builder.Build();

        app.UseHttpsRedirection();

        var summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        app.MapGet("/weatherforecast", (HttpContext httpContext) =>
        {
            var forecast = Enumerable.Range(1, 5).Select(index =>
                new WeatherForecast
                {
                    Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
                    TemperatureC = Random.Shared.Next(-20, 55),
                    Summary = summaries[Random.Shared.Next(summaries.Length)]
                })
                .ToArray();
            return forecast;
        });

        app.Run();
    }
}

Ambos proyectos de API hacen referencia a la siguiente clase:

namespace APIWithControllers;

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

    public int TemperatureC { get; set; }

    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);

    public string? Summary { get; set; }
}

Las API mínimas tienen muchas de las mismas funcionalidades que las API basadas en controlador. Admiten la configuración y la personalización necesarias para escalar a varias API, controlar rutas complejas, aplicar reglas de autorización y controlar el contenido de las respuestas de las API. Hay algunas funcionalidades disponibles con las API basadas en controlador que aún no son compatible con las API mínimas o no las implementan. Entre ellas se incluyen las siguientes:

• No hay compatibilidad integrada con el enlace de modelos (IModelBinderProvider, IModelBinder). Se puede agregar compatibilidad con una corrección de compatibilidad de enlace personalizada.
• No hay compatibilidad integrada con la validación (IModelValidator).
• No se admiten elementos de aplicación ni el modelo de aplicación. No hay ninguna manera de aplicar o crear sus propias convenciones.
• No hay soporte integrado para la renderización de vistas. Se recomienda usar Razor Pages para representar vistas.
• No se admite JsonPatch.
• No se admite OData.

Consulte también

• Cree API web con ASP.NET Core.
• Tutorial: Creación de una API web basada en controlador con ASP.NET Core
• Introducción a las API mínimas
• Tutorial: Creación de una API mínima con ASP.NET Core