Scegliere tra API basate su controller e API minime

ASP.NET Core supporta due approcci alla creazione di API: un approccio basato su controller e API minime. I controller in un progetto API sono classi che derivano da ControllerBase. Le API minime definiscono gli endpoint con gestori logici in espressioni lambda o metodi. Questo articolo illustra le differenze tra i due approcci.

La progettazione di API minime nasconde la classe host per impostazione predefinita e si concentra sulla configurazione e sull'estendibilità tramite metodi di estensione che accettano funzioni come espressioni lambda. I controller sono classi che possono accettare dipendenze tramite l'inserimento di costruttori o l'inserimento di proprietà e in genere seguono modelli orientati agli oggetti. Le API minime supportano l'inserimento delle dipendenze tramite altri approcci, ad esempio l'accesso al provider di servizi.

Ecco il codice di esempio per un'API basata sui controller:

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();
    }
}

Il codice seguente fornisce la stessa funzionalità in un progetto API minimo. Si noti che l'approccio API minimo prevede l'inclusione del codice correlato nelle espressioni 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();
    }
}

Entrambi i progetti API fanno riferimento alla classe seguente:

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; }
}

Le API minime hanno molte delle stesse funzionalità delle API basate su controller. Supportano la configurazione e la personalizzazione necessarie per ridimensionare più API, gestire route complesse, applicare regole di autorizzazione e controllare il contenuto delle risposte API. Esistono alcune funzionalità disponibili con le API basate su controller che non sono ancora supportate o implementate da API minime. tra cui:

• Nessun supporto predefinito per l'associazione di modelli (IModelBinderProvider, IModelBinder). È possibile aggiungere il supporto con uno shim di associazione personalizzato.
• Nessun supporto predefinito per la convalida (IModelValidator).
• Nessun supporto per le parti dell'applicazione o il modello applicativo. Non è possibile applicare o creare convenzioni personalizzate.
• Nessun supporto per il rendering delle visualizzazioni predefinito. È consigliabile usare Razor Pages per il rendering delle visualizzazioni.
• Nessun supporto per JsonPatch
• Nessun supporto per OData

Vedi anche

• Creare API Web con ASP.NET Core.
• Esercitazione: Creare un'API Web con ASP.NET Core
• Panoramica delle API minime
• Esercitazione: Creare un'API minima con ASP.NET Core