.NET MAUI nel 2026: Sviluppo Cross-Platform e Domande per Colloqui Tecnici

.NET MAUI (Multi-platform App UI) si è affermato come framework cross-platform maturo e pronto per la produzione con .NET 10. Rilasciato come versione Long-Term Support con supporto fino a novembre 2028, .NET MAUI 10 viene distribuito come workload e pacchetti NuGet, offrendo miglioramenti in qualità, performance e nuove API come i potenziamenti di HybridWebView e SafeAreaEdges. Questo tutorial guida attraverso la creazione di un'app cross-platform, spiega l'architettura alla base di MAUI e affronta le domande di colloquio che i responsabili delle assunzioni pongono nel 2026.

Configurare un Progetto .NET MAUI 10 da Zero

Il percorso più rapido verso un'app MAUI funzionante inizia con la .NET CLI. .NET 10 introduce un template di progetto aggiornato che include i service defaults di .NET Aspire, collegando telemetria e service discovery out of the box.

# Install the MAUI workload (if not already present)
dotnet workload install maui

# Create a new MAUI app
dotnet new maui -n CrossPlatformDemo
cd CrossPlatformDemo

# Run on Android emulator
dotnet build -t:Run -f net10.0-android

La struttura a progetto singolo consolida il codice specifico per piattaforma sotto una cartella Platforms/, condividendo tutto il resto. Il file MauiProgram.cs funge da composition root — è qui che vengono registrati servizi, font e handlers.

using Microsoft.Extensions.Logging;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .ConfigureFonts(fonts =>
            {
                fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            });

        // Register services for dependency injection
        builder.Services.AddSingleton<IApiService, ApiService>();
        builder.Services.AddTransient<MainViewModel>();

#if DEBUG
        builder.Logging.AddDebug();
#endif

        return builder.Build();
    }
}

La dependency injection in MAUI segue lo stesso pattern di ASP.NET Core. I servizi Singleton persistono per l'intera durata dell'app, i servizi Transient vengono creati per ogni richiesta, e i servizi Scoped — sebbene disponibili — richiedono cautela perché MAUI non possiede un concetto nativo di scope come le richieste HTTP.

Handlers: L'Architettura Dietro al Rendering Cross-Platform

MAUI ha sostituito i renderer di Xamarin.Forms con un'architettura basata su handler. Gli handler mappano ogni controllo cross-platform al suo corrispettivo nativo attraverso un sottile livello di astrazione. La differenza fondamentale: gli handler sono stateless e disaccoppiati dalla virtual view, rendendoli più veloci e più facili da personalizzare.

using Microsoft.Maui.Handlers;

public class CustomEntryHandler : EntryHandler
{
    protected override void ConnectHandler(MauiAppCompatEditText platformView)
    {
        base.ConnectHandler(platformView);
        // Remove the default underline on Android
        platformView.SetBackgroundColor(Android.Graphics.Color.Transparent);
    }
}

// Register in MauiProgram.cs
builder.ConfigureMauiHandlers(handlers =>
{
    handlers.AddHandler<Entry, CustomEntryHandler>();
});

In .NET 10, i controlli Entry e Editor su Android sono passati da AppCompatEditText a MauiAppCompatEditText, aggiungendo il supporto nativo per l'evento SelectionChanged. I miglioramenti ai CollectionView e CarouselView handler introdotti in .NET 9 sono ora predefiniti su iOS e Mac Catalyst, risolvendo problemi di stabilità di lunga data.

MVVM con CommunityToolkit.Mvvm: Eliminare il Boilerplate

Il source generator di CommunityToolkit.Mvvm elimina circa l'80% del codice cerimoniale MVVM. Nessuna implementazione manuale di INotifyPropertyChanged, nessun wrapper per i command — gli attributi guidano la generazione del codice.

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

public partial class MainViewModel : ObservableObject
{
    private readonly IApiService _apiService;

    public MainViewModel(IApiService apiService)
    {
        _apiService = apiService;
    }

    // Source generator creates the 'Title' property with change notification
    [ObservableProperty]
    private string _title = string.Empty;

    // Source generator creates the 'IsLoading' property
    [ObservableProperty]
    private bool _isLoading;

    // Source generator creates an async ICommand
    [RelayCommand]
    private async Task LoadDataAsync()
    {
        IsLoading = true;
        try
        {
            Title = await _apiService.FetchTitleAsync();
        }
        finally
        {
            IsLoading = false;
        }
    }
}

Il XAML si lega direttamente alle proprietà e ai command generati:

<!-- MainPage.xaml -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:vm="clr-namespace:CrossPlatformDemo.ViewModels"
             x:DataType="vm:MainViewModel">
    <VerticalStackLayout Padding="20" Spacing="16">
        <Label Text="{Binding Title}"
               FontSize="24"
               HorizontalOptions="Center" />
        <Button Text="Load Data"
                Command="{Binding LoadDataCommand}"
                IsEnabled="{Binding IsLoading, Converter={StaticResource InverseBoolConverter}}" />
        <ActivityIndicator IsRunning="{Binding IsLoading}"
                           IsVisible="{Binding IsLoading}" />
    </VerticalStackLayout>
</ContentPage>

L'attributo x:DataType abilita i compiled binding, che sono più veloci dei binding basati su reflection e producono errori a compile-time quando un percorso di binding è errato.

HybridWebView in .NET 10: Il Ponte tra Nativo e Web

HybridWebView consente di incorporare contenuti web all'interno di un'app MAUI mantenendo la comunicazione bidirezionale tra C# e JavaScript. .NET 10 aggiunge tre funzionalità: invocazione JavaScript fire-and-forget, eventi di inizializzazione per la configurazione specifica della piattaforma e intercettazione delle richieste web.

public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();

        // Initialization event for platform-specific tweaks
        hybridWebView.WebViewInitialized += (sender, args) =>
        {
            // Access the native platform view after initialization
            System.Diagnostics.Debug.WriteLine("WebView ready");
        };
    }

    // Call JavaScript from C#
    private async void OnCallJsClicked(object sender, EventArgs e)
    {
        var result = await hybridWebView.InvokeJavaScriptAsync<string>(
            "getFormData",  // JS function name
            HybridSampleContext.Default.String  // JSON serialization context
        );
        await DisplayAlert("Result", result, "OK");
    }

    // Fire-and-forget: no return type needed (.NET 10)
    private async void OnResetClicked(object sender, EventArgs e)
    {
        await hybridWebView.InvokeJavaScriptAsync("resetForm");
    }
}

Il JavaScript corrispondente riceve le chiamate e può inviare messaggi di ritorno a C#:

function getFormData() {
    return JSON.stringify({
        name: document.getElementById('name').value,
        email: document.getElementById('email').value
    });
}

function resetForm() {
    document.getElementById('name').value = '';
    document.getElementById('email').value = '';
}

Le eccezioni JavaScript lanciate durante InvokeJavaScriptAsync vengono ora automaticamente inoltrate a .NET come eccezioni, eliminando i fallimenti silenziosi.

SafeAreaEdges: Layout Perfetti su Ogni Dispositivo

.NET MAUI 10 introduce la proprietà SafeAreaEdges per Layout, ContentView, ContentPage, Border e ScrollView. Il nuovo enum (None, SoftInput, Container, Default, All) sostituisce il legacy Page.UseSafeArea specifico per iOS con un approccio cross-platform.

<!-- Granular safe area control per section -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             SafeAreaEdges="All">
    <Grid RowDefinitions="Auto,*,Auto">
        <!-- Header respects all safe areas -->
        <Border Grid.Row="0" SafeAreaEdges="Container">
            <Label Text="Header" />
        </Border>

        <!-- Content scrolls under safe areas -->
        <ScrollView Grid.Row="1" SafeAreaEdges="SoftInput">
            <VerticalStackLayout Padding="16">
                <Entry Placeholder="Type here..." />
            </VerticalStackLayout>
        </ScrollView>

        <!-- Footer avoids home indicator -->
        <Border Grid.Row="2" SafeAreaEdges="Container">
            <Label Text="Footer" />
        </Border>
    </Grid>
</ContentPage>

SoftInput adatta il contenuto quando appare la tastiera virtuale. Container evita i notch, gli alloggiamenti dei sensori e l'indicatore home. Questi possono essere combinati per ogni controllo, permettendo a un header di posizionarsi sotto la barra di stato mentre l'area contenuti rimane libera.

Migrazione da Xamarin.Forms a .NET MAUI

Il supporto per Xamarin.Forms è terminato a maggio 2024. La migrazione a MAUI richiede modifiche strutturali che vanno oltre un semplice scambio di namespace. Ecco una checklist di migrazione basata su conversioni di progetti reali:

1. Struttura del progetto — Conversione dai progetti specifici per piattaforma al modello single-project di MAUI. Il codice condiviso va nella root, il codice specifico per piattaforma sotto Platforms/.
2. Namespace — Sostituire Xamarin.Forms con Microsoft.Maui.Controls e Xamarin.Essentials con Microsoft.Maui.Essentials (ora integrato in MAUI).
3. Renderer a Handler — I custom renderer devono essere riscritti come handler. L'API degli handler è più semplice, ma la logica di mapping è differente.
4. Startup — Sostituire l'inizializzazione App.xaml.cs con MauiProgram.cs utilizzando il builder pattern.
5. Pacchetti NuGet — Molti pacchetti dell'era Xamarin hanno equivalenti MAUI. Verificare la compatibilità prima dell'upgrade.
6. Dependency injection — MAUI utilizza Microsoft.Extensions.DependencyInjection nativamente. Sostituire qualsiasi container DI di terze parti o chiamate a DependencyService.

Il .NET Upgrade Assistant automatizza parti dei passaggi 1-2, ma gli handler (passaggio 3) e gli aggiustamenti della logica di business richiedono lavoro manuale.

Le Domande di Colloquio più Importanti su .NET MAUI per il 2026

Queste domande riflettono ciò che i team di sviluppo chiedono nei colloqui del 2026, basandosi sull'ecosistema attuale .NET 10.

Come si differenzia l'architettura handler di MAUI dai renderer di Xamarin.Forms?

I renderer in Xamarin.Forms erano strettamente accoppiati sia al controllo cross-platform che alla view nativa, creando una dipendenza bidirezionale. Gli handler in MAUI sono mapper stateless: ricevono notifiche di cambiamento delle proprietà e le applicano alla view nativa attraverso un dizionario di mapping. Questo disaccoppiamento rende gli handler più facili da testare, estendere e riutilizzare. I dizionari PropertyMapper e CommandMapper sostituiscono il pattern di override OnElementPropertyChanged, rendendo la personalizzazione esplicita invece di nasconderla in blocchi switch.

Quali sono le insidie dei lifetime DI specifiche di MAUI?

MAUI supporta i lifetime Singleton, Transient e Scoped, ma Scoped si comporta diversamente rispetto ad ASP.NET Core. Non esiste un confine di scope naturale (come una richiesta HTTP). Un servizio Scoped registrato in MAUI agisce come un Singleton a meno che non vengano creati scope personalizzati manualmente. Errori comuni: registrare un ViewModel come Singleton quando contiene stato specifico della pagina (dati obsoleti durante la navigazione), o registrare una connessione al database come Transient (esaurimento del connection pool). La regola generale: i ViewModel sono Transient, i servizi sono Singleton, e Scoped viene evitato a meno che il ciclo di vita dello scope non sia gestito esplicitamente.

Come si differenzia il compiled binding dal binding basato su reflection in MAUI?

I binding basati su reflection risolvono i percorsi delle proprietà a runtime usando System.Reflection, il che è lento e produce errori a runtime in caso di errori di battitura. I compiled binding, abilitati con x:DataType, risolvono i percorsi di binding a compile-time. Il compilatore genera codice di accesso diretto alle proprietà, saltando completamente la reflection. Questo migliora il tempo di avvio, riduce le allocazioni di memoria e intercetta gli errori di binding durante la build. In .NET 10, il nuovo source generator XAML ottimizza ulteriormente compilando il XAML a build-time invece di parsificarlo a runtime.

Quali strategie esistono per condividere codice tra un'app MAUI e un backend ASP.NET Core?

L'approccio raccomandato utilizza una shared class library contenente DTO, logica di validazione e regole di business. Sia l'app MAUI che il backend ASP.NET Core fanno riferimento a questa libreria. .NET 10 rafforza questo pattern con la nuova integrazione .NET Aspire per MAUI, che fornisce service discovery e telemetria attraverso progetti mobile e backend. I contratti condivisi con System.Text.Json source generator assicurano la consistenza della serializzazione. Il vincolo chiave: la shared library deve targetizzare net10.0 (non TFM specifici per piattaforma) per rimanere portabile.

Come si differenzia HybridWebView da BlazorWebView in MAUI?

BlazorWebView ospita un'applicazione Blazor completa all'interno dell'app MAUI. I componenti Razor vengono renderizzati in un WebView incorporato, ma il runtime .NET viene eseguito nativamente (non tramite WebAssembly). HybridWebView è più leggero: carica contenuti HTML/CSS/JS statici e fornisce interop C#-to-JavaScript senza l'overhead del framework Blazor. La scelta dipende dal caso d'uso. BlazorWebView è adatto per team con componenti Blazor esistenti che desiderano riutilizzare il codice. HybridWebView è adatto per scenari dove contenuti web esistenti (dashboard, mappe, editor) necessitano di integrazione nativa senza un framework completo.

Altre domande di colloquio .NET su SharpSkill permettono di consolidare questi concetti con esercizi interattivi.

Conclusione

• .NET MAUI 10 è un rilascio LTS (supporto fino a novembre 2028) focalizzato su stabilità e performance, non sul turnover di feature — una scelta affidabile per app cross-platform in produzione
• L'architettura handler sostituisce i renderer Xamarin con mapper stateless, migliorando testabilità e personalizzazione attraverso PropertyMapper e CommandMapper
• I source generator di CommunityToolkit.Mvvm rimuovono la maggior parte del boilerplate MVVM — gli attributi [ObservableProperty] e [RelayCommand] sostituiscono le implementazioni manuali di INotifyPropertyChanged e dei command
• HybridWebView in .NET 10 aggiunge chiamate JavaScript fire-and-forget, eventi di inizializzazione e intercettazione delle richieste per l'integrazione nativo-web
• SafeAreaEdges fornisce un controllo granulare e cross-platform su notch, tastiere e barre di sistema, sostituendo il legacy UseSafeArea solo per iOS
• La migrazione da Xamarin.Forms richiede la riscrittura degli handler e il refactoring dello startup — il .NET Upgrade Assistant gestisce i cambi di namespace, ma il lavoro manuale rimane per i custom renderer
• La preparazione ai colloqui dovrebbe concentrarsi su architettura handler vs. renderer, insidie dei lifetime DI nelle app a lunga esecuzione, compiled binding e trade-off tra HybridWebView e BlazorWebView