FastEndpoints: Un’alternativa per le API Web in C#

FastEndpoints è un framework open-source per la creazione di API web in C#, progettato per essere un’alternativa leggera e performante ai Minimal API e ai controller MVC di ASP.NET Core. Offre un approccio semplificato allo sviluppo di API, riducendo il codice boilerplate e migliorando le prestazioni, senza sacrificare flessibilità o potenza. Il progetto può essere visionato al link https://fast-endpoints.com/ .

Perché scegliere FastEndpoints?

FastEndpoints si distingue per diverse caratteristiche che lo rendono una scelta interessante per gli sviluppatori C#:

• Leggerezza: FastEndpoints è un framework minimale che si concentra sull’essenziale, evitando dipendenze inutili e riducendo l’overhead.
• Prestazioni: Grazie alla sua architettura ottimizzata, FastEndpoints offre prestazioni elevate, paragonabili o superiori a quelle dei Minimal API e significativamente migliori rispetto ai controller MVC.
• Semplicità: FastEndpoints promuove un approccio “code-first” con una sintassi intuitiva e concisa, riducendo il codice boilerplate e semplificando lo sviluppo.
• Flessibilità: Nonostante la sua semplicità, FastEndpoints offre un alto grado di flessibilità, consentendo di personalizzare il comportamento delle API in base alle esigenze specifiche.
• Manutenibilità: La struttura chiara e organizzata di FastEndpoints facilita la manutenzione e l’evoluzione delle API nel tempo.

Il pattern REPR

FastEndpoints incoraggia l’adozione del pattern REPR (Request-Endpoint-Response), che promuove una separazione netta tra le diverse responsabilità all’interno dell’API:

• Request: Definisce i dati in ingresso all’endpoint, inclusi i parametri dalla query string, dal corpo della richiesta e dagli header.
• Endpoint: Gestisce la logica di elaborazione della richiesta, inclusa la validazione dei dati, l’interazione con i servizi e la generazione della risposta.
• Response: Definisce i dati in uscita dall’endpoint, inclusi il codice di stato HTTP e il corpo della risposta.

Questo pattern contribuisce a migliorare la leggibilità, la testabilità e la manutenibilità del codice.

Installazione e configurazione

Per iniziare a utilizzare FastEndpoints, è sufficiente installare il pacchetto NuGet FastEndpoints nel proprio progetto ASP.NET Core:

Install-Package FastEndpoints

Successivamente, è necessario configurare FastEndpoints nel metodo ConfigureServices della classe Startup:

public void ConfigureServices(IServiceCollection services)
{
    services.AddFastEndpoints();
    // ... altre configurazioni ...
}

oppure

using FastEndpoints;

var bld = WebApplication.CreateBuilder();
bld.Services.AddFastEndpoints();

var app = bld.Build();
app.UseFastEndpoints();
app.Run();

Creazione di un nuovo endpoint

Vediamo ora un esempio pratico di creazione di un endpoint con FastEndpoints. Supponiamo di voler creare un endpoint per ottenere l’elenco di tutti i prodotti da un database.

1. Definizione della richiesta:

public class GetAllProductsRequest : IRequest<GetAllProductsResponse>
{
}

In questo caso, la richiesta non ha parametri, poiché vogliamo ottenere tutti i prodotti.

2. Definizione della risposta:

public class GetAllProductsResponse
{
    public List<Product> Products { get; set; }
}

La risposta conterrà una lista di oggetti Product.

3. Definizione dell’endpoint:

public class GetAllProductsEndpoint : Endpoint
{
private readonly IProductService _productService;

public class GetAllProductsEndpoint : Endpoint<GetAllProductsRequest, GetAllProductsResponse>
{
    private readonly IProductService _productService;

    public GetAllProductsEndpoint(IProductService productService)
    {
        _productService = productService;
    }

    public override void Configure()
    {
        Get("/products");
        AllowAnonymous();
    }

    public override async Task HandleAsync(GetAllProductsRequest request, CancellationToken ct)
    {
        var products = await _productService.GetAllProductsAsync();
        Response = new GetAllProductsResponse { Products = products };
    }
}

In questo esempio, l’endpoint eredita dalla classe Endpoint<TRequest, TResponse> e implementa il metodo HandleAsync per gestire la richiesta. Il metodo Configure viene utilizzato per configurare l’endpoint, specificando il verbo HTTP (Get), il percorso (/products) e le politiche di autorizzazione (AllowAnonymous).

4. Definizione del servizio:

public interface IProductService
{
    Task<List<Product>> GetAllProductsAsync();
}

public class ProductService : IProductService
{
    // ... implementazione del servizio ...
}

Il servizio ProductService si occupa di recuperare i prodotti dal database.

5. Registrazione del servizio:

public void ConfigureServices(IServiceCollection services)
{
    services.AddFastEndpoints();
    services.AddScoped<IProductService, ProductService>();
    // ... altre configurazioni ...
}

nfine, è necessario registrare il servizio ProductService nel contenitore di dependency injection.

Con questi semplici passaggi, abbiamo creato un endpoint RESTful completo e funzionale con FastEndpoints.

Vantaggi di FastEndpoints

L’utilizzo di FastEndpoints offre numerosi vantaggi rispetto ad altri framework per la creazione di API web in C#:

• Riduzione del codice boilerplate: FastEndpoints elimina gran parte del codice ripetitivo tipico dei controller MVC, consentendo di concentrarsi sulla logica di business.
• Miglioramento delle prestazioni: Grazie alla sua architettura leggera e ottimizzata, FastEndpoints offre prestazioni elevate, superiori a quelle dei controller MVC e paragonabili a quelle dei Minimal API.
• Maggiore leggibilità e manutenibilità: Il pattern REPR e la sintassi concisa di FastEndpoints rendono il codice più facile da leggere, comprendere e manutenere.
• Migliore testabilità: La separazione netta tra le diverse responsabilità all’interno dell’API facilita la scrittura di test unitari.
• Flessibilità e personalizzazione: FastEndpoints offre un alto grado di flessibilità, consentendo di personalizzare il comportamento delle API in base alle esigenze specifiche.