in Architettura Software, Informatica |

Abilitare la Compilazione in Fase di Runtime con Razor Pages in ASP.NET Core

Lo sviluppo di applicazioni web con ASP.NET Core, in particolare utilizzando il modello Razor Pages, offre un’esperienza moderna e produttiva. Tuttavia, uno degli aspetti che può interrompere il flusso di lavoro è la necessità di ricompilare e riavviare l’applicazione dopo ogni piccola modifica ai file .cshtml (le Razor Pages).

Fortunatamente, ASP.NET Core offre una soluzione elegante per questo problema: la Compilazione in Fase di Runtime (Runtime Compilation). Abilitare questa funzionalità può trasformare drasticamente il tuo ciclo di sviluppo.

Che Cos’è la Compilazione in Fase di Runtime?

In un’applicazione ASP.NET Core standard, tutte le Razor Views e Razor Pages (file .cshtml) vengono compilate in assembly C# all’avvio dell’applicazione (o durante il processo di build). Quando apporti una modifica a un file .cshtml, il runtime normalmente non ne è a conoscenza finché l’applicazione non viene fermata e ricompilata.

La Compilazione in Fase di Runtime risolve questo problema. Quando è abilitata, il framework monitora le modifiche ai file .cshtml. Se viene rilevata una modifica, solo i file Razor interessati vengono ricompilati al volo (in background o alla successiva richiesta HTTP che li invoca), senza richiedere un riavvio completo dell’applicazione.

Questo si traduce in un feedback immediato e in un ciclo di modifica-salvataggio-aggiornamento del browser estremamente più rapido per le modifiche all’interfaccia utente (UI) e alla logica di presentazione.

Come Abilitare la Runtime Compilation

Abilitare la compilazione in fase di runtime in un progetto Razor Pages di ASP.NET Core è un processo semplice che coinvolge l’installazione di un pacchetto NuGet e l’aggiunta di una riga di configurazione nel file Program.cs.

1. Installazione del Pacchetto NuGet

Il primo passo consiste nell’installare il pacchetto NuGet Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation.

È possibile farlo tramite la CLI di .NET:

Bash

dotnet add package Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation

Oppure tramite la console di Gestione Pacchetti (Package Manager Console) in Visual Studio:

PowerShell

Install-Package Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation

Questo pacchetto contiene le librerie necessarie per abilitare la ricompilazione just-in-time dei file Razor.

2. Configurazione in Program.cs

Dopo l’installazione, è necessario registrare il servizio di compilazione in fase di runtime nel container dei servizi dell’applicazione, tipicamente nel file Program.cs (utilizzando il modello Minimal APIs di .NET 6/7/8+).

Nella sezione di configurazione dei servizi, aggiungi la chiamata a .AddRazorRuntimeCompilation() dopo la chiamata a AddRazorPages():

C#

var builder = WebApplication.CreateBuilder(args);

// Aggiungi servizi al container.
builder.Services.AddRazorPages()
    // Aggiungi la compilazione in fase di runtime
    .AddRazorRuntimeCompilation(); 

var app = builder.Build();

// ... (altre configurazioni come middleware)

app.Run();

Nota: Se stai ancora utilizzando il modello Startup.cs di .NET 5 o precedente, la configurazione andrà nel metodo ConfigureServices:

C#

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages()
        .AddRazorRuntimeCompilation();
}

Configurazione Condizionale (Solo Sviluppo)

In un ambiente di produzione (Production), l’utilizzo della compilazione in fase di runtime è sconsigliato in quanto può influire negativamente sulle prestazioni. L’approccio migliore è abilitarla solo nell’ambiente di Sviluppo (Development).

È possibile condizionare l’abilitazione utilizzando la proprietà EnvironmentName del WebApplicationBuilder:

C#

var builder = WebApplication.CreateBuilder(args);

var razorPagesBuilder = builder.Services.AddRazorPages();

// Abilita la Runtime Compilation solo in ambiente di Sviluppo
if (builder.Environment.IsDevelopment())
{
    razorPagesBuilder.AddRazorRuntimeCompilation();
}

// ...

Vantaggi Chiave per gli Sviluppatori

L’adozione della compilazione in fase di runtime offre numerosi vantaggi che ottimizzano il processo di sviluppo:

  1. Massima Velocità di Iterazione (Fast Iteration Loop): Questo è il vantaggio principale. Non devi più aspettare il riavvio completo dell’applicazione per vedere le modifiche al codice HTML, CSS inline o al codice Razor.
  2. Migliore Concentrazione (Reduced Context Switching): Riducendo l’attesa, mantieni alta la concentrazione sul codice che stai scrivendo, migliorando la produttività complessiva.
  3. Supporto per i File Aggiunti: La compilazione in fase di runtime non solo gestisce le modifiche, ma è anche in grado di rilevare e includere nuovi file Razor Pages o Views che aggiungi al progetto durante l’esecuzione, senza un riavvio.
  4. Esperienza Utente Migliorata (DevEx): Nel complesso, l’esperienza di sviluppo (DevEx) diventa più fluida e meno frustrante, specialmente quando si lavora sull’ottimizzazione dell’interfaccia utente.

Considerazioni e Best Practice

Sebbene la Runtime Compilation sia uno strumento potente, è fondamentale utilizzarla in modo appropriato:

  • Ambiente di Sviluppo: Usala solo nell’ambiente di sviluppo (Development). Come menzionato, in ambienti di produzione, l’overhead di monitoraggio e ricompilazione potrebbe avere un impatto sulle prestazioni.
  • Modifiche al Codice C# (Non-Razor): Tieni presente che la compilazione in fase di runtime si applica solo ai file .cshtml e alle classi associate. Se modifichi il codice C# puro (come servizi, controller, backend logic in generale), dovrai comunque ricompilare e riavviare l’applicazione per applicare tali modifiche. Per queste modifiche, strumenti come Hot Reload di .NET possono offrire un’esperienza simile di riavvio “a caldo”.
  • Prestazioni Iniziali: La prima richiesta ad una pagina dopo una modifica al file .cshtml potrebbe essere leggermente più lenta, in quanto è in quel momento che avviene la ricompilazione. Tutte le richieste successive saranno veloci finché non viene apportata un’altra modifica.

Abilitare la Runtime Compilation in ASP.NET Core con Razor Pages è un passo essenziale per qualsiasi sviluppatore che miri a massimizzare l’efficienza nello sviluppo dell’interfaccia utente. È uno di quegli accorgimenti di configurazione che, una volta applicato, ti chiederai come hai fatto a lavorare senza.