Migrazione da Web Forms ASP.NET a Blazor

Migrazione da Web Forms ASP.NET a Blazor

Migrazione da Web Forms ASP.NET a Blazor

ASP.NET Web Forms è un framework web basato su .NET Framework (solo Windows) per creare applicazioni web con pagine .aspx e code-behind in C#. Adotta un modello di sviluppo basato su eventi (simile a Windows Forms) con controlli server (<asp:GridView>, <asp:Button>, ecc.) che generano markup HTML. In Web Forms il ciclo di vita della pagina (postback, ViewState) gestisce automaticamente gli eventi dell’interfaccia. Microsoft definisce Web Forms “un framework applicativo web maturo incluso in .NET Framework completo”. Questo significa che Web Forms è stabile e supportato (su .NET Framework 4.8+), ma non è stato riscritto nel mondo .NET Core/5+.

Blazor è un framework web più recente basato su .NET (parte di ASP.NET Core) che permette di scrivere interfacce web interattive in C# anziché JavaScript. I componenti Blazor (Razor Components) generano HTML dinamico e possono essere eseguiti in due modalità principali:

  • Blazor Server: il codice C# viene eseguito sul server ASP.NET Core, e gli aggiornamenti UI vengono inviati al browser tramite una connessione SignalR (WebSocket) . In pratica il browser mostra la pagina inizialmente generata e ogni interazione richiama metodi C# sul server, che restituisce soltanto le modifiche HTML da applicare.
  • Blazor WebAssembly: l’intera app Blazor (compresa un runtime .NET) viene scaricata ed eseguita nel browser tramite WebAssembly . In questo caso il codice .NET gira sul client, interagendo direttamente con il DOM e chiamando eventualmente API esterne. Una volta scaricati i file statici, l’applicazione può funzionare anche offline come Progressive Web App.

Blazor offre così un modello moderno a componenti, code-sharing tra client e server, e pieno accesso a librerie .NET in entrambi i hosting.

Tendenze tecniche di Microsoft – Migrazione da Web Forms ASP.NET a Blazor

Microsoft ha spostato gran parte dello sviluppo web verso ASP.NET Core/.NET 6+, un framework open-source e multipiattaforma che unifica .NET Core e .NET Framework. In questo contesto, Web Forms non è stato portato su .NET Core o .NET 8 e rimane vincolato a Windows. In altre parole, Microsoft non introdurrà nuove funzionalità in Web Forms su ASP.NET Core: “il team .NET ha chiarito che ASP.NET Web Forms non verrà portato in .NET Core o .NET 8” . Di conseguenza, per applicazioni nuove si preferiscono tecnologie come MVC, Razor Pages o Blazor (che supportano sviluppo cross-platform e moderne pratiche open-source).

Tuttavia, Web Forms rimarrà supportato finché .NET Framework sarà parte di Windows: Microsoft conferma che “ASP.NET Web Forms continuerà a essere un modo produttivo per scrivere app web per molti anni” sui server Windows . In sintesi, Web Forms è considerato un prodotto maturo (“legacy”) con manutenzione garantita, ma il futuro è orientato a .NET Core/5+ e Blazor, specialmente per scenari multipiattaforma e con richieste di nuove funzionalità.

Perché è utile migrare da Web Forms a Blazor

La migrazione a Blazor diventa utile quando servono i vantaggi delle tecnologie più moderne. In generale, Web Forms può continuare a funzionare, ma Blazor offre nuove capacità non disponibili in Web Forms. Microsoft sottolinea che solo le app migrate possono sfruttare certe funzionalità avanzate. Ad esempio, con Blazor si ottiene:

  • Migliori prestazioni: .NET 6/7/8 introduce costrutti come Span<T> e ottimizzazioni JIT/AOT che velocizzano l’esecuzione del codice rispetto al vecchio Framework .
  • Esecuzione WebAssembly: gli applicativi Blazor possono girare direttamente nel browser (Blazor WASM), riducendo il carico sul server e abilitando il funzionamento offline.
  • Cross-platform: Blazor (su .NET Core/7) funziona su Windows, Linux e macOS, permettendo di sviluppare e distribuire l’applicazione in ambienti diversi . Web Forms, al contrario, è limitato a IIS/Windows.
  • Deployment flessibile: con .NET Core si può distribuire l’app come framework condiviso oppure self-contained, evitando conflitti tra app sul server. Inoltre Blazor semplifica la distribuzione come app statiche (per WASM).

Inoltre, Blazor adotta un modello a componenti più moderno e facilita lo sviluppo con C# sia sul front-end che sul back-end. Questo semplifica la manutenibilità: la stessa logica business in librerie .NET può essere riutilizzata direttamente nei componenti Blazor. Infine, la comunità e gli aggiornamenti Microsoft si concentrano su .NET Core e Blazor, per cui migrare garantisce supporto alle ultime librerie e strumenti. In sintesi, se la vostra applicazione Web Forms funziona già bene e girerà sempre su Windows, la migrazione non è obbligatoria; ma per ottenere i vantaggi sopra elencati diventa consigliabile riscrivere o portare il progetto su Blazor.

Come effettuare la migrazione

La migrazione da Web Forms a Blazor richiede una buona pianificazione. Una regola generale è separare chiaramente la logica di business dall’interfaccia: per esempio usando un’architettura a più livelli (N-tier), in modo da riutilizzare facilmente i servizi dati e la logica già esistente.

Esistono almeno due approcci principali:

  • Migrazione completa “rifacendo” l’app: si crea un nuovo progetto ASP.NET Core (ad esempio Blazor Server o Blazor WebAssembly) e si riscrivono tutte le pagine in componenti Blazor. In questo modello si porta gradualmente la logica di business (magari già separata in classi/librerie indipendenti) nel nuovo progetto, e si ricostruiscono interfaccia e gestione dati in Blazor. Questo approccio richiede più lavoro upfront ma alla fine tutte le pagine saranno moderne. Ad esempio si potrebbe partire da un template Blazor Server, rifattorizzare i modelli dati (es. con Entity Framework Core) e creare componenti Razor per ogni vecchia pagina ASPX.
  • Migrazione graduale (ibrida): si tiene in parallelo parte dell’applicazione Web Forms e si aggiungono man mano pagine o funzionalità in Blazor. Ad esempio si possono creare API o servizi intermedi (ad esempio ASP.NET Core Web API) per la logica dati esistente, e sviluppare pagine Blazor che le consumano (anche nello stesso dominio). In questo modo, si convertono le singole pagine ASPX in componenti Razor una per una, lasciando che il resto dell’app continui ad usare Web Forms. Microsoft nota che la migrazione “può essere eseguita sull’intera app o solo su determinati endpoint”. Un’alternativa ibrida meno comune è ospitare componenti Blazor in pagine esistenti (ad esempio con ASP.NET Core -> Web Forms tramite iframe/JS, o con progetti Razor Class Library), ma in genere è più semplice mantenere due front-end separati fino alla fine della migrazione.

In pratica si inizia creando un nuovo progetto Blazor (Server o WASM) e si integra la logica esistente: ad esempio si possono aggiungere pacchetti NuGet usati nel vecchio progetto, installare il Windows Compatibility Pack se si usano funzionalità Windows-only, e configurare Program.cs (sostituendo il vecchio Global.asax). Il passo successivo è rivedere la parte UI: ogni pagina .aspx va riscritta come componente .razor. Le operazioni sui dati (CRUD) possono usare lo stesso backend (ad esempio Entity Framework Core) o richieste HTTP alle vecchie API. Infine, si testa ciascuna parte migrata mantenendo operativa l’implementazione legacy finché la sostituzione è completa. In breve, si tratta di spostare gradualmente la UI e la logica dal vecchio progetto al nuovo, verificando che ogni pezzo funzioni in Blazor.

Esempio pratico di migrazione (CRUD)

Per illustrare la differenza, consideriamo una semplice pagina che gestisce un elenco di Prodotti con operazioni di lettura e cancellazione.

Web Forms (Prodotti.aspx) – Esempio di pagina .aspx con un GridView collegato a un’origine dati (ad esempio ADO.NET/SqlDataSource) che mostra tutti i prodotti, con un pulsante “Elimina”:

<!-- Pagina Web Forms (Prodotti.aspx) -->
<asp:GridView ID="GridView1" runat="server" DataKeyNames="Id"
    AutoGenerateColumns="False" OnRowDeleting="GridView1_RowDeleting">
  <Columns>
    <asp:BoundField DataField="Id" HeaderText="ID" ReadOnly="True" />
    <asp:BoundField DataField="Name" HeaderText="Nome" />
    <asp:ButtonField CommandName="Delete" Text="Elimina" />
  </Columns>
</asp:GridView>

Il codice dietro (Prodotti.aspx.cs) carica i dati e gestisce l’evento di cancellazione:

// Code-behind: carica dati e gestisce la cancellazione
protected void Page_Load(object sender, EventArgs e)
{
    if (!IsPostBack)
    {
        // Codice per collegare il GridView al database (es. tramite SqlDataAdapter)
        BindGrid();
    }
}

// Gestore evento: viene chiamato quando si clicca "Elimina"
protected void GridView1_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
    int id = Convert.ToInt32(GridView1.DataKeys[e.RowIndex].Value);
    // Esempio: eliminare il prodotto dal database (SqlCommand DELETE, EF, ecc.)
    DeleteProductById(id);
    BindGrid(); // ricarica l'elenco dopo l'eliminazione
}

Blazor (Prodotti.razor) – La stessa funzionalità in un componente Razor (ad esempio in Blazor Server). In questo caso iniettiamo un ProductService (che usa EF Core o simili) per ottenere i dati. Il markup è una tabella HTML generata con un foreach, e il metodo C# DeleteProduct viene invocato al click del pulsante:

@page "/prodotti"
@inject ProductService ProductService

<h3>Elenco Prodotti</h3>
<table>
  <thead>
    <tr><th>ID</th><th>Nome</th><th></th></tr>
  </thead>
  <tbody>
    @foreach (var p in products)
    {
      <tr>
        <td>@p.Id</td>
        <td>@p.Name</td>
        <td>
          <button class="btn btn-danger" @onclick="() => DeleteProduct(p.Id)">Elimina</button>
        </td>
      </tr>
    }
  </tbody>
</table>

@code {
    private List<Product> products;

    protected override async Task OnInitializedAsync()
    {
        products = await ProductService.GetProductsAsync();  // carica prodotti dal DB
    }

    private async Task DeleteProduct(int id)
    {
        await ProductService.DeleteProductAsync(id);       // cancella dal DB
        products = await ProductService.GetProductsAsync(); // ricarica lista aggiornata
    }
}

Nel codice Blazor vediamo che l’interfaccia è completamente basata su HTML/CSS standard e la logica C# è scritta in un blocco @code. Non ci sono controlli server tipo <asp:GridView>: al loro posto usiamo normali tag HTML e metodi C# asincroni. Il risultato è equivalente: quando l’utente clicca “Elimina”, viene chiamato DeleteProduct(id) in C#, che aggiorna il database e refresha la lista. Nel caso di Blazor Server, il metodo C# viene eseguito sul server (via SignalR) e poi il browser aggiorna la tabella con gli elementi rimossi. In Blazor WebAssembly, analogamente, il codice potrebbe chiamare un’API HTTP per cancellare il prodotto sul server backend, e poi aggiornare i dati nel browser, il tutto senza mai fare un “postback” completo.

Questo esempio mostra un esempio di Migrazione da Web Forms ASP.NET a Blazor, in particolare come una pagina Web Forms CRUD possa essere riscritta in Blazor mantenendo la stessa logica di business, ma con un modello di programmazione più moderno e meno dipendente da controlli server. Naturalmente, in un’applicazione reale si dovrebbe gestire anche l’aggiunta/modifica di prodotti, validazioni, ed eventualmente l’uso di componenti condivisi, ma il principio resta lo stesso: sostituire i controlli ASPX con componenti Razor e usare l’iniezione di dipendenze per i servizi dati.

(fonte) (fonte) (fonte)

Innovaformazione, scuola informatica specialistica promuove la cultura dell’aggiornamento costante per gli sviluppatori ed affianca le aziende nella formazione del team IT. Trovate l’elenco corsi in ambiente .Net sul nostro sito QUI.

Per altri articoli tecnici consigliamo di navigare sul nostro blog QUI.

INFO: info@innovaformazione.net – tel. 3471012275 (Dario Carrassi)

Ti potrebbe interessare

Articoli correlati