.NET 9 Blazor: Sviluppo Full-Stack con Blazor United nel 2026

Blazor United rappresenta l'evoluzione definitiva del framework Blazor di Microsoft in .NET 9, offrendo un approccio unificato allo sviluppo full-stack che elimina i compromessi tradizionali tra rendering statico e interattività. Questa architettura permette agli sviluppatori di combinare Server-Side Rendering (SSR) statico, interattività basata su SignalR e WebAssembly all'interno della stessa applicazione, selezionando la modalità ottimale per ogni singolo componente.

L'introduzione di Blazor United in .NET 9 segna un punto di svolta significativo nell'ecosistema .NET: non è più necessario scegliere tra Blazor Server e Blazor WebAssembly all'inizio del progetto. Il framework gestisce automaticamente la transizione tra le diverse modalità di rendering, garantendo prestazioni eccellenti, ottimizzazione SEO e un'esperienza utente fluida. Questa flessibilità rende Blazor una piattaforma competitiva per qualsiasi tipo di applicazione web, dai siti marketing alle dashboard enterprise in tempo reale.

Configurazione di un Blazor Web App in .NET 9

La creazione di un nuovo progetto Blazor con supporto completo a Blazor United richiede l'utilizzo del template blazorweb, che configura automaticamente tutte le modalità di rendering disponibili. L'opzione --interactivity Auto abilita la modalità automatica, mentre --all-interactive false garantisce che solo i componenti esplicitamente contrassegnati siano interattivi, lasciando il resto dell'applicazione in modalità SSR statico per massimizzare le prestazioni.

# Create a new Blazor Web App with all render modes enabled
dotnet new blazorweb -n FullStackApp --interactivity Auto --all-interactive false
cd FullStackApp
dotnet run

Questo comando genera una struttura di progetto modulare con separazione chiara tra componenti statici e interattivi. Il template include automaticamente la configurazione per SignalR, il caricamento lazy di WebAssembly e l'infrastruttura per lo streaming rendering. L'applicazione risultante è pronta per la produzione con ottimizzazioni predefinite per bundle size, caching e performance.

Modalità di Rendering in Blazor United

Blazor United introduce quattro modalità di rendering distinte, ognuna ottimizzata per scenari specifici. La scelta della modalità corretta influenza direttamente prestazioni, scalabilità e esperienza utente.

| Modalità di Rendering | Hosting | Interattività | Ideale per | |---|---|---|---| | SSR Statico | Server | Nessuna | Pagine marketing, documentazione, contenuti SEO | | Server Interattivo | Server via SignalR | Completa | Dashboard, CRUD, form | | WebAssembly Interattivo | Browser via WASM | Completa | Scenari offline, logica client complessa | | Auto Interattivo | Server poi WASM | Completa | Equilibrio ottimale — caricamento rapido + indipendenza |

Il SSR statico genera HTML puro sul server senza overhead JavaScript, risultando ideale per contenuti che non richiedono interattività. Server Interattivo mantiene una connessione SignalR persistente, permettendo aggiornamenti in tempo reale con logica C# eseguita interamente sul server. WebAssembly Interattivo scarica il runtime .NET nel browser, eseguendo tutto il codice lato client senza dipendenze dal server dopo il caricamento iniziale.

La modalità Auto rappresenta il punto di forza di Blazor United: inizia con rendering server per garantire Time-to-Interactive rapido, poi scarica automaticamente WebAssembly in background, passando a esecuzione client senza interruzioni. Questo approccio combina la velocità di caricamento del server con l'indipendenza del client.

@page "/dashboard"
@rendermode InteractiveServer

<PageTitle>Dashboard</PageTitle>

<h1>Real-Time Metrics</h1>

<!-- This component renders interactively via SignalR -->
<MetricsChart />

<!-- Static content below renders as plain HTML -->
<footer>Updated every 5 seconds</footer>

In questo esempio, la pagina utilizza @rendermode InteractiveServer per abilitare aggiornamenti real-time tramite SignalR. Il componente MetricsChart può invocare callback C# sul server e ricevere aggiornamenti push senza polling, mentre il footer rimane statico per ridurre il carico computazionale.

Gli sviluppatori possono anche rilevare programmaticamente la modalità di rendering corrente utilizzando RendererInfo, permettendo di adattare il comportamento dei componenti in base al contesto di esecuzione:

@if (RendererInfo.IsInteractive)
{
    <button @onclick="HandleClick">Interactive Action</button>
}
else
{
    <a href="/fallback">Static Fallback Link</a>
}

@code {
    private void HandleClick()
    {
        // Runs only in interactive modes (Server or WASM)
    }
}

Questa strategia garantisce graceful degradation: se il componente viene renderizzato in modalità statica, l'applicazione fornisce un fallback funzionale senza errori runtime.

Streaming Rendering per Pagine Asincrone

Lo streaming rendering in .NET 9 risolve uno dei problemi storici dello sviluppo web: l'attesa del caricamento completo dei dati prima di visualizzare qualsiasi contenuto. Con l'attributo [StreamRendering], Blazor invia immediatamente l'HTML iniziale al browser, poi aggiorna progressivamente la pagina man mano che i dati asincroni diventano disponibili.

@page "/products"
@attribute [StreamRendering]

<PageTitle>Product Catalog</PageTitle>

@if (products is null)
{
    <p>Loading products...</p>
}
else
{
    <div class="product-grid">
        @foreach (var product in products)
        {
            <ProductCard Item="@product" />
        }
    </div>
}

@code {
    private List<Product>? products;

    // Data loads asynchronously; streaming pushes updates to the browser
    protected override async Task OnInitializedAsync()
    {
        products = await ProductService.GetAllAsync();
    }
}

Quando un utente accede a /products, Blazor invia subito l'HTML con il messaggio "Loading products...". Mentre ProductService.GetAllAsync() esegue la query al database, il browser visualizza già la pagina. Non appena i dati arrivano, Blazor aggiorna automaticamente il DOM senza JavaScript aggiuntivo, sostituendo il placeholder con la griglia di prodotti.

Questo approccio migliora significativamente la percezione delle prestazioni: il First Contentful Paint (FCP) avviene immediatamente, mentre il Largest Contentful Paint (LCP) si completa non appena i dati sono pronti. A differenza delle SPA tradizionali che mostrano spinner globali, lo streaming rendering fornisce feedback visivo granulare e progressivo.

Lo streaming funziona perfettamente anche con componenti nidificati: ogni componente con operazioni asincrone può aggiornarsi indipendentemente, permettendo pattern sofisticati come skeleton screens e caricamento progressivo di sezioni complesse.

Dependency Injection con Primary Constructor

.NET 9 introduce i primary constructor per le classi C#, e Blazor li supporta completamente per semplificare la dependency injection nei componenti. Al posto del verbose pattern con proprietà [Inject], gli sviluppatori possono dichiarare le dipendenze direttamente nella firma del componente.

@page "/orders"
@rendermode InteractiveServer

<h2>Order History</h2>

@if (orders is not null)
{
    <table>
        <thead>
            <tr><th>Order ID</th><th>Date</th><th>Total</th></tr>
        </thead>
        <tbody>
            @foreach (var order in orders)
            {
                <tr>
                    <td>@order.Id</td>
                    <td>@order.PlacedAt.ToShortDateString()</td>
                    <td>@order.Total.ToString("C")</td>
                </tr>
            }
        </tbody>
    </table>
}

@code {
    // Constructor injection via primary constructor
    [Inject] public required IOrderService OrderService { get; set; }
    [Inject] public required NavigationManager Nav { get; set; }

    private List<Order>? orders;

    protected override async Task OnInitializedAsync()
    {
        orders = await OrderService.GetRecentOrdersAsync();
    }
}

In questo esempio, OrderService e NavigationManager vengono iniettati automaticamente dal container DI di Blazor. Il modificatore required garantisce che il framework fornisca sempre queste dipendenze, generando errori compile-time se mancano registrazioni nel Program.cs.

Questo pattern riduce il boilerplate e rende i componenti più leggibili, mantenendo tutti i benefici dell'inversione di controllo. Gli sviluppatori possono testare facilmente i componenti mockando le interfacce iniettate, seguendo le best practice di architettura pulita.

Modalità Interactive Auto per Applicazioni Moderne

La modalità InteractiveAuto rappresenta il compromesso ideale per applicazioni che richiedono sia velocità di caricamento che ricche interazioni client. Blazor avvia il componente in modalità Server, garantendo rendering immediato senza attendere il download del runtime WASM. In background, il framework scarica il runtime .NET WebAssembly e i DLL necessari, poi transita automaticamente a esecuzione client.

@page "/chat"
@rendermode InteractiveAuto

<h2>Live Chat</h2>

<div class="chat-messages">
    @foreach (var msg in messages)
    {
        <div class="message">@msg.Author: @msg.Text</div>
    }
</div>

<input @bind="newMessage" @onkeydown="HandleKey" placeholder="Type a message..." />

@code {
    [Inject] public required IChatService ChatService { get; set; }

    private List<ChatMessage> messages = new();
    private string newMessage = string.Empty;

    protected override async Task OnInitializedAsync()
    {
        messages = await ChatService.GetRecentMessagesAsync();
    }

    private async Task HandleKey(KeyboardEventArgs e)
    {
        if (e.Key == "Enter" && !string.IsNullOrWhiteSpace(newMessage))
        {
            await ChatService.SendAsync(newMessage);
            newMessage = string.Empty;
        }
    }
}

Per componenti come chat in tempo reale, questa modalità offre vantaggi significativi: l'utente vede immediatamente l'interfaccia e può iniziare a digitare mentre il client WASM si carica. Una volta completato il download, le successive interazioni avvengono completamente nel browser senza latenza di rete, migliorando drasticamente la reattività percepita.

La transizione da Server a WASM avviene in modo trasparente senza reset dello stato del componente. Blazor serializza lo stato corrente, lo trasferisce al client WASM e riprende l'esecuzione esattamente dove la modalità Server si era fermata. Gli utenti non notano alcuna interruzione, mantenendo continuità nell'esperienza.

Riconnessione e Resilienza delle Connessioni

Le applicazioni Blazor Server dipendono da connessioni SignalR persistenti, che possono interrompersi per vari motivi: problemi di rete, timeout, riavvii del server. .NET 9 introduce meccanismi avanzati di riconnessione configurabili per mantenere la sessione utente anche in condizioni di rete instabili.

Blazor.start({
    circuit: {
        reconnectionOptions: {
            retryIntervalMilliseconds: (retryNumber) => {
                // Exponential backoff: 200ms, 400ms, 800ms, max 30s
                return Math.min(200 * Math.pow(2, retryNumber), 30000);
            },
            maxRetries: 15
        }
    }
});

Questa configurazione implementa un backoff esponenziale: il primo tentativo di riconnessione avviene dopo 200ms, il secondo dopo 400ms, il terzo dopo 800ms, fino a un massimo di 30 secondi tra tentativi. Dopo 15 tentativi falliti, Blazor mostra un'interfaccia di errore permettendo all'utente di ricaricare manualmente la pagina.

Durante la riconnessione, Blazor mantiene lo stato del componente in memoria, evitando la perdita di dati non salvati. L'interfaccia mostra automaticamente un banner di stato ("Tentativo di riconnessione...") senza bloccare completamente l'interazione. Se la riconnessione ha successo entro il timeout del circuito server (configurabile), l'applicazione riprende esattamente dallo stato precedente.

Per applicazioni mission-critical, gli sviluppatori possono intercettare eventi di disconnessione e implementare strategie personalizzate, come il salvataggio automatico dello stato in LocalStorage o la transizione a una modalità offline con sincronizzazione differita.

SSR Statico con Interattività Selettiva

Una delle capacità più potenti di Blazor United è la possibilità di disabilitare selettivamente l'interattività per pagine specifiche, anche quando l'applicazione utilizza interattività globale. Questo approccio è essenziale per ottimizzare SEO e prestazioni di pagine statiche come documentazione, termini di servizio o pagine marketing.

@page "/privacy"
@attribute [ExcludeFromInteractiveRouting]

<PageTitle>Privacy Policy</PageTitle>

<!-- This page always renders as static HTML -->
<!-- Even if global interactivity is enabled -->
<article>
    <h1>Privacy Policy</h1>
    <p>Last updated: April 2026</p>
    <!-- Content -->
</article>

L'attributo [ExcludeFromInteractiveRouting] forza il rendering statico puro, eliminando completamente l'overhead di SignalR o WebAssembly per quella specifica route. I crawler dei motori di ricerca ricevono HTML statico ottimizzato, senza JavaScript bloccante, migliorando drasticamente i punteggi Lighthouse e i Core Web Vitals.

Questo pattern permette architetture ibride sofisticate: un'applicazione può avere il dashboard completamente interattivo con @rendermode InteractiveAuto globale, mentre landing page, blog e documentazione rimangono puramente statici. Gli utenti beneficiano di caricamenti istantanei per contenuti informativi e interattività completa per funzionalità applicative.

La navigazione tra pagine statiche e interattive avviene senza ricaricamenti completi: Blazor utilizza Enhanced Navigation, un sistema di routing lato client che aggiorna solo il contenuto modificato, mantenendo header, footer e layout condivisi. Questo garantisce transizioni fluide simili alle SPA pur mantenendo i vantaggi SEO del SSR.

Prestazioni con Ahead-of-Time Compilation

Per applicazioni WebAssembly Interattive, .NET 9 supporta la compilazione Ahead-of-Time (AOT), che compila il codice C# direttamente in istruzioni macchina native del browser invece di utilizzare l'interpretazione Just-in-Time. Questo comporta miglioramenti drammatici nelle prestazioni runtime, con esecuzioni fino a 2-3 volte più veloci per operazioni intensive.

# Publish with AOT for production
dotnet publish -c Release -p:RunAOTCompilation=true

La compilazione AOT analizza l'intero albero delle dipendenze, elimina codice morto (tree shaking) e applica ottimizzazioni aggressive come inlining, loop unrolling e constant folding. Il risultato è un bundle WASM ottimizzato che esegue operazioni computazionalmente intensive — come manipolazione di grandi dataset, rendering di grafici o elaborazione di immagini — con prestazioni paragonabili alle applicazioni native.

Per molte applicazioni, la modalità Auto con AOT rappresenta il setup ideale: rendering server immediato per First Paint veloce, poi transizione a WASM AOT per prestazioni client eccezionali una volta caricato il bundle.

Conclusione

Blazor United in .NET 9 ridefinisce lo sviluppo full-stack nell'ecosistema Microsoft, offrendo un livello di flessibilità e prestazioni che rivaleggia con framework JavaScript consolidati come Next.js e Nuxt. La capacità di combinare rendering statico, interattività server e client nella stessa applicazione elimina le scelte architetturali binarie che tradizionalmente limitavano le opzioni degli sviluppatori.

Le innovazioni chiave di questa versione includono:

• Unified Rendering Architecture: una singola codebase supporta SSR statico, Server Interattivo, WASM Interattivo e modalità Auto senza duplicazione di logica
• Streaming Rendering Avanzato: aggiornamenti progressivi del DOM per migliorare significativamente le metriche di performance percepita
• Resilienza Nativa: gestione automatica di disconnessioni, riconnessioni e transizioni tra modalità senza perdita di stato
• Ottimizzazione Granulare: controllo preciso su quali componenti richiedono interattività e quali possono rimanere statici
• Prestazioni Competitive: AOT compilation e lazy loading portano WASM a livelli di performance paragonabili ad applicazioni native

Per sviluppatori che lavorano già nell'ecosistema .NET, Blazor United elimina la necessità di framework JavaScript separati per il frontend, permettendo di utilizzare competenze C# end-to-end. Per team che valutano nuove piattaforme, Blazor offre un'alternativa seria con eccellenti tooling, supporto enterprise e integrazione nativa con Azure.

Il futuro dello sviluppo web tende verso architetture ibride che massimizzano i vantaggi di ogni approccio di rendering. Blazor United non solo abbraccia questa tendenza, ma fornisce l'implementazione più matura e completa attualmente disponibile nel panorama .NET, posizionandosi come scelta strategica per applicazioni web moderne e scalabili nel 2026 e oltre.