Guida WinUI 3 Microsoft
Guida WinUI 3 Microsoft
Se sviluppi in ambiente .NET da qualche anno, probabilmente conosci bene quella sensazione: aprire un vecchio gestionale aziendale in Windows Forms o WPF e chiedersi come portarlo nel presente senza dover riscrivere da zero decenni di logica di business. Per lungo tempo, il mondo dello sviluppo desktop su Windows ha vissuto una sorta di sdoppiamento: da una parte la potenza e la libertà di Win32, dall’altra la modernità grafica ma i vincoli della sandbox UWP.
Con WinUI 3 e il Windows App SDK, Microsoft ha finalmente ricomposto questo puzzle. In questa mini guida tecnica vediamo cos’è davvero WinUI 3, quando e perché è nato, come si distribuisce (Packaged vs Unpackaged) e come realizzare due scenari tipici da applicazione desktop enterprise con snippet di codice essenziali.
Indice dei contenuti – Guida WinUI 3 Microsoft
1. Che cos’è WinUI 3 e qual è la sua architettura
2. Quando nasce WinUI 3: dal Project Reunion al Windows App SDK
3. A cosa serve oggi e quando sceglierlo nello sviluppo .NET
4. Panoramica sulla distribuzione: applicazioni Packaged e Unpackaged
5. Esempio pratico 1: Gestione ordini enterprise con Data Binding e MVVM
6. Esempio pratico 2: Finestra di conferma critica con ContentDialog asincrono
7. Best practice per lo sviluppo desktop in WinUI 3
8. Limiti attuali e punti di attenzione da conoscere
9. Conclusioni, aggiornamento tecnologico e formazione per team IT
1. Che cos’è WinUI 3 e qual è la sua architettura
Iniziamo la nostra Guida WinUI 3 Microsoft. WinUI 3 (Windows UI Library 3) è il framework nativo di interfaccia utente consigliato da Microsoft per la creazione di nuove applicazioni desktop su Windows. A differenza dei suoi predecessori legati al ciclo di rilascio del sistema operativo, WinUI 3 viene distribuito come componente principale del Windows App SDK (precedentemente noto come Project Reunion).
Dal punto di vista architetturale, WinUI 3 separa completamente il livello di presentazione XAML e il motore di composizione grafica dal sistema operativo sottostante. Questo significa che un’applicazione sviluppata in C# (.NET) o C++ (Win32) può sfruttare i controlli Fluent Design, il rendering ad alte prestazioni basato su DirectX e il supporto agli schermi ad alta densità di pixel (High DPI) su qualsiasi versione compatibile di Windows, a partire da Windows 10 versione 1809 (build 17763) fino alle ultime release di Windows 11.
- Linguaggi supportati: C# con .NET moderno oppure C++ nativo (C++/WinRT) con markup XAML.
- Namespace dedicato: Tutti i controlli e le classi UI risiedono sotto Microsoft.UI.Xaml (distinguendosi nettamente dal vecchio Windows.UI.Xaml di UWP).
- Modello applicativo Win32 completo: L’app gira con pieno accesso alle API di sistema, al file system, al registro e alle librerie .NET standard, senza le restrizioni della sandbox UWP.
2. Quando nasce WinUI 3: dal Project Reunion al Windows App SDK
Per capire la genesi di WinUI 3 bisogna tornare al 2020. Fino ad allora gli sviluppatori Windows si trovavano davanti a un bivio scomodo: scegliere WinForms o WPF (stabili e potenti, ma con interfacce datate e API moderne difficili da integrare) oppure UWP (moderna e fluida, ma vincolata al Microsoft Store, alla sandbox e all’aggiornamento del sistema operativo degli utenti).
Nel maggio 2020, durante la conferenza Microsoft Build, viene annunciato Project Reunion con un obiettivo chiaro: disaccoppiare le API della piattaforma Windows dal sistema operativo e renderle disponibili tramite pacchetti NuGet a tutte le app desktop. Da questa iniziativa nasce il Windows App SDK (la cui versione 1.0 viene rilasciata stabilmente alla fine del 2021) e, al suo interno, WinUI 3.
Prima di WinUI 3 esisteva WinUI 2, che però era soltanto una libreria di controlli aggiuntivi per le app UWP. WinUI 3 ha invece estratto l’intero motore XAML, il compositor visivo e il sistema di input di Windows, trasformandolo in un framework completo e autonomo per il mondo desktop Win32 e .NET.
3. A cosa serve oggi e quando sceglierlo nello sviluppo .NET
WinUI 3 serve a costruire applicazioni desktop Windows di livello produttivo che richiedono prestazioni elevate, integrazione profonda con l’hardware e un’esperienza utente coerente con Windows 11. Non è un caso che parti della stessa shell di Windows 11 e utility ufficiali come Microsoft PowerToys siano realizzate proprio con WinUI.
- Nuovi software gestionali e applicativi verticali su Windows: Ideale quando il target aziendale è l’ecosistema Windows e si vuole un’interfaccia moderna, accessibile e reattiva.
- Modernizzazione di legacy app WPF o WinForms: Permette di migrare gradualmente o di affiancare tramite XAML Islands componenti moderni all’interno di applicazioni esistenti.
- Applicazioni ad alta intensità grafica o hardware: Grazie al rendering hardware-accelerated, alla gestione avanzata del windowing e all’integrazione con le Windows AI APIs e Windows ML per l’inferenza locale su CPU, GPU e NPU.
4. Panoramica sulla distribuzione: applicazioni Packaged e Unpackaged
Uno degli aspetti più apprezzati dai team enterprise riguarda la flessibilità di rilascio. A differenza di UWP, WinUI 3 supporta due modalità principali di distribuzione:
- Applicazioni Packaged (MSIX): È la modalità predefinita dei template Visual Studio. L’applicazione viene impacchettata in formato MSIX, ottenendo una package identity. Questo abilita installazione e disinstallazione pulite senza sporcare il registro, aggiornamenti automatici tramite App Installer o Microsoft Store, notifiche push, background task e gestione integrata delle risorse.
- Applicazioni Unpackaged: Impostando la proprietà <WindowsPackageType>None</WindowsPackageType> nel file .csproj, l’app viene compilata come un classico eseguibile desktop senza identità di pacchetto. Può essere distribuita tramite installer tradizionali (WiX, Inno Setup), script aziendali o cartelle condivise, scegliendo tra modalità framework-dependent (che richiede il runtime del Windows App SDK sulla macchina client) oppure self-contained (che include il runtime direttamente nella cartella dell’app, supportando anche PublishSingleFile).
5. Esempio pratico 1: Gestione ordini enterprise con Data Binding e MVVM
La Guida WinUI 3 Microsoft entra nella pratica. Immaginiamo di dover realizzare una vista di monitoraggio ordini all’interno di un ERP desktop aziendale. L’utente deve visualizzare un elenco di commesse e poterle contrassegnare come evase con un clic, aggiornando immediatamente l’interfaccia.
Per mantenere il codice pulito e testabile utilizziamo il pattern MVVM con il pacchetto ufficiale CommunityToolkit.Mvvm, che grazie ai Source Generator riduce al minimo il codice boilerplate.
Passaggio 1: Creazione del progetto e installazione del pacchetto MVVM
In Visual Studio selezionare il modello ‘App vuota WinUI (confezionata)’ in C# (.NET) e aggiungere via NuGet il pacchetto CommunityToolkit.Mvvm.
Passaggio 2: Definizione del Model e del ViewModel (MainViewModel.cs)
using System.Collections.ObjectModel;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
public partial class Ordine : ObservableObject
{
public string Codice { get; init; } = string.Empty;
public string Cliente { get; init; } = string.Empty;
[ObservableProperty]
private string stato = "In lavorazione";
}
public partial class MainViewModel : ObservableObject
{
public ObservableCollection<Ordine> Ordini { get; } = new()
{
new Ordine { Codice = "ORD-2026-01", Cliente = "Acme Logistics Srl" },
new Ordine { Codice = "ORD-2026-02", Cliente = "Beta Engineering SpA" }
};
[RelayCommand]
private void EvadiOrdine(Ordine? ordine)
{
if (ordine is not null)
{
ordine.Stato = "Evaso";
}
}
}
Passaggio 3: Collegamento alla vista XAML con x:Bind (MainWindow.xaml)
In WinUI 3 si preferisce x:Bind rispetto al classico Binding perché viene risolto a tempo di compilazione, offrendo prestazioni superiori e controllo statico dei tipi.
<Window
x:Class="EnterpriseOrdersApp.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:EnterpriseOrdersApp">
<Grid Padding="24" RowSpacing="16">
<ListView ItemsSource="{x:Bind ViewModel.Ordini}">
<ListView.ItemTemplate>
<DataTemplate x:DataType="local:Ordine">
<StackPanel Orientation="Horizontal" Spacing="16" Padding="8">
<TextBlock Text="{x:Bind Codice}" FontWeight="SemiBold" Width="120"/>
<TextBlock Text="{x:Bind Cliente}" Width="200"/>
<TextBlock Text="{x:Bind Stato, Mode=OneWay}" Width="130"/>
</StackPanel>
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
</Grid>
</Window>
6. Esempio pratico 2: Finestra di conferma critica con ContentDialog asincrono
Un altro scenario ricorrente nelle applicazioni enterprise riguarda le operazioni irreversibili, come la chiusura contabile o la cancellazione massiva di record. In WinUI 3 non si usano più le vecchie MessageBox bloccanti di Win32, ma il controllo modale ContentDialog, gestito in modo completamente asincrono e ancorato allo XamlRoot della finestra attiva.
Passaggio 1: Dichiarazione del pulsante di azione nella UI (MainWindow.xaml)
<StackPanel Padding="24" Spacing="12">
<Button Content="Chiudi Periodo Contabile" Click="OnChiudiPeriodoClick"/>
<TextBlock x:Name="EsitoText" Text="Stato: in attesa di conferma"/>
</StackPanel>
Passaggio 2: Istanziazione e attesa asincrona del dialogo (MainWindow.xaml.cs)
Nota tecnica fondamentale: in WinUI 3 un’applicazione può gestire più finestre contemporaneamente, quindi è obbligatorio valorizzare la proprietà XamlRoot del ContentDialog prima di chiamare ShowAsync().
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using System;
public sealed partial class MainWindow : Window
{
public MainWindow()
{
this.InitializeComponent();
}
private async void OnChiudiPeriodoClick(object sender, RoutedEventArgs e)
{
ContentDialog dialog = new()
{
XamlRoot = this.Content.XamlRoot,
Title = "Conferma chiusura contabile",
Content = "L'operazione bloccherà tutte le modifiche al registro IVA. Procedere?",
PrimaryButtonText = "Conferma",
CloseButtonText = "Annulla",
DefaultButton = ContentDialogButton.Close
};
ContentDialogResult result = await dialog.ShowAsync();
EsitoText.Text = result == ContentDialogResult.Primary
? "Stato: periodo contabile chiuso."
: "Stato: operazione annullata dall'utente.";
}
}
7. Best practice per lo sviluppo desktop in WinUI 3
Adottare WinUI 3 in un contesto aziendale richiede di applicare fin da subito alcune buone pratiche architetturali per evitare debito tecnico:
- Privilegiare x:Bind compilato rispetto a Binding: Riduce l’uso di reflection a runtime, velocizza il rendering delle liste complesse e segnala errori di battitura già in fase di compilazione.
- Mantenere il thread UI libero: Sfruttare costantemente async/await per chiamate HTTP, query su database e accesso ai file, usando DispatcherQueue solo quando è strettamente necessario aggiornare elementi visivi da un thread secondario.
- Separare UI e logica con MVVM: Usare CommunityToolkit.Mvvm per isolare i ViewModel dai dettagli della vista, facilitando i test unitari e l’eventuale riutilizzo del codice.
- Curare accessibilità e scalabilità DPI: Verificare sempre la navigazione da tastiera, il supporto agli screen reader (tramite Accessibility Insights for Windows) e il comportamento su monitor multipli con fattori di scala differenti.
- Pianificare la strategia di aggiornamento: Valutare MSIX con App Installer in ambienti gestiti da Intune o domini aziendali, oppure predisporre installer silenziosi per le distribuzioni unpackaged.
8. Limiti attuali e punti di attenzione da conoscere
Essere trasparenti sui compromessi tecnologici aiuta gli architetti software a fare scelte consapevoli. Nonostante la maturità raggiunta dal Windows App SDK, WinUI 3 presenta ancora alcuni limiti da considerare:
- Solo piattaforma Windows: WinUI 3 è progettato esclusivamente per Windows 10 (1809+) e Windows 11. Se il requisito aziendale prevede macOS o Linux, occorre valutare alternative come .NET MAUI, Avalonia UI oppure Uno Platform (che riutilizza proprio la sintassi WinUI).
- Designer XAML visuale limitato rispetto a WPF: Sebbene XAML Hot Reload e Live Visual Tree funzionino in modo affidabile per modificare l’interfaccia a runtime, manca un designer drag-and-drop maturo come quello storico di WinForms o WPF (e Blend per Visual Studio non è supportato).
- Dimensioni del pacchetto in modalità Self-Contained: Distribuire un’app unpackaged includendo l’intero runtime del Windows App SDK incrementa sensibilmente l’occupazione su disco rispetto a un eseguibile WinForms.
- Alcune API avanzate richiedono Package Identity: In modalità unpackaged non sono disponibili funzionalità legate al manifest del pacchetto come aggiornamenti automatici tramite App Installer o alcune estensioni della shell.
9. Conclusioni, aggiornamento tecnologico e formazione per team IT
Il mondo dello sviluppo desktop è tutt’altro che tramontato: nei settori industriale, bancario, sanitario, logistico e della pubblica amministrazione, le applicazioni native Windows restano il cuore operativo quotidiano. Tuttavia, continuare a mantenere interfacce obsolete o architetture legacy comporta costi crescenti in termini di usabilità, sicurezza e difficoltà nel reperire nuovi talenti.
Aggiornarsi agli strumenti moderni dell’ecosistema .NET e al Windows App SDK permette alle aziende di proteggere gli investimenti fatti sul codice C# esistente, offrendo al contempo agli utenti finali software veloci, sicuri e allineati agli standard visivi contemporanei.
Formazione IT dedicata per aziende e team di sviluppo
Per accompagnare i team di sviluppatori .NET nella transizione verso le tecnologie desktop moderne, consigliamo i Corsi IT di Innovaformazione, scuola di formazione specializzata nell’ambito ICT. Su richiesta aziendale, Innovaformazione eroga il Corso WinUI 3 in modalità online classe virtuale (con docente in diretta e laboratori pratici), calendario da concordare in base alle esigenze operative del team e preventivo dedicato.
Per ricevere il programma dettagliato o richiedere informazioni: info@innovaformazione.net – tel. 3471012275 (referente Dario Carrassi).
Per altri articoli tecnici e di settore consigliamo di navigare sul nostro blog QUI.
Articoli correlati
Java4Shell vulnerabilità
Costruiamo un Second Brain AI
Lavorare con SAP: ecco un’opportunità interessante!
Guida LLM Wiki
Claude Code con Arduino
