C#: concetti chiave del linguaggio, sviluppo .NET MAUI e Xamarin

Cos'è C#?

C# (pronunciato "si sharp") è un linguaggio di programmazione orientato agli oggetti con un sistema di tipi sicuro, sviluppato da Microsoft nel 2000 sotto la guida di Anders Hejlsberg. Il nome è ispirato dalla notazione musicale (diesis — innalzamento del tono). C# funziona sulla piattaforma .NET, che include Common Language Runtime (CLR) e un'ampia libreria di classi (BCL — Base Class Library).

Nello sviluppo mobile, C# viene utilizzato attraverso due tecnologie: Xamarin (2011–2024) e il suo successore .NET MAUI (2022+). Xamarin permetteva di creare applicazioni native Android e iOS con codice C# condiviso, separando i progetti specifici della piattaforma. .NET MAUI combina tutte le piattaforme in un unico progetto con markup XAML condiviso e accesso alle API native tramite interfacce di piattaforma.

Una caratteristica chiave di C# è la tipizzazione statica rigorosa con possibilità di dispatch dinamico tramite dynamic, la parola chiave var (inferenza del tipo) e un potente sistema di generics. C# è un linguaggio completamente gestito: la memoria è gestita dal garbage collector (GC), i limiti degli array vengono controllati, le variabili non inizializzate sono vietate. Questo rende C# più sicuro di C++ con prestazioni comparabili tramite compilazione AOT.

Versioni di C# ed evoluzione

C# 1.0 (2000) — linguaggio OOP di base. C# 3.0 (2007) — LINQ, espressioni lambda, metodi di estensione. C# 6.0 (2015) — interpolazione di stringhe, operatore null-conditional. C# 8.0 (2019) — tipi di riferimento nullable (sicurezza null), flussi asincroni, metodi di interfaccia predefiniti. C# 10 (2021) — global usings, spazi dei nomi per file, record struct. C# 12 (2023) — costruttori primari, espressioni di raccolta, intercettatori. Ogni versione apporta miglioramenti rilevanti per lo sviluppo mobile.

Sintassi C#: tipi, classi e LINQ

La sintassi C# è simile al C, rigorosamente tipizzata. Tutto è un oggetto, inclusi i primitivi (int, double, bool — sono strutture che ereditano ValueType). C# divide i tipi in tipi valore (int, double, bool, struct, enum — memorizzati nello stack) e tipi riferimento (string, class, interface, delegate, array, record — memorizzati nell'heap). I tipi nullable (int?) permettono null per i tipi valore.

Tipi di dati e classi

C# supporta classi (class), strutture (struct), record (record), interfacce (interface), enumerazioni (enum) e delegati (delegate). record è un tipo riferimento immutabile con uguaglianza basata sul valore (due record sono uguali se tutti i loro campi sono uguali). record struct è la versione valore di record, introdotta in C# 10. I costruttori primari (C# 12) combinano dichiarazione e inizializzazione in una riga.

// Tipi base e classi in C#
using System;
using System.Collections.Generic;

// Record con costruttore primario (C# 12)
public record User(int Id, string Name, string Email);

// Classe con proprietà nullable
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

    // Metodo con corpo di espressione
    public string GetDisplayName() => $"{AppName} v{Version}";
}

// Metodo di estensione
public static class StringExtensions
{
    public static bool IsValidEmail(this string email) =>
        email.Contains("@") && email.Contains(".");
}

// Utilizzo
var user = new User(1, "Alice", "alice@example.com");
bool validEmail = user.Email.IsValidEmail();

Il record User con costruttore primario genera automaticamente equals, hashCode, toString, Deconstruct e with-copia. I setter init-only (AppName) permettono di impostare un valore solo nell'inizializzatore. Il corpo di espressione (=>) è una notazione concisa per metodi semplici. Il metodo di estensione IsValidEmail aggiunge un metodo a string senza ereditarietà.

LINQ — Language Integrated Query

LINQ è un linguaggio di query integrato per collezioni, database, XML. LINQ to Objects — query a collezioni IEnumerable. LINQ to SQL — a database. LINQ to XML — a XML. La sintassi può essere query (from u in users where u.Age > 18 select u) e metodo (users.Where(u => u.Age > 18).Select(u => u)). Caricamento differito (esecuzione ritardata): la query viene eseguita all'iterazione, non alla dichiarazione.

// Query LINQ su collezioni
using System.Linq;

var users = new List<User>
{
    new User(1, "Alice", "alice@example.com"),
    new User(2, "Bob", "bob@test.com"),
    new User(3, "Charlie", "charlie@example.com"),
};

// Sintassi di query
var filteredUsers = from u in users
                     where u.Email.Contains("example")
                     orderby u.Name
                     select u;

// Sintassi di metodo con più operazioni
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

// GroupBy e aggregazione
var emailsByDomain = users
    .GroupBy(u => u.Email.Split('@')[1])
    .Select(g => new { Domain = g.Key, Count = g.Count() });

// LINQ con flusso asincrono (IAsyncEnumerable)
await foreach (var user in GetUsersAsync())
{
    Console.WriteLine(user.Name);
}

async IAsyncEnumerable<User> GetUsersAsync()
{
    yield return new User(1, "Alice", "alice@example.com");
    await Task.Delay(100);
    yield return new User(2, "Bob", "bob@test.com");
}

La query LINQ filteredUsers filtra gli utenti per dominio email e ordina per nome. La sintassi di metodo .Where().OrderBy().Select() è una catena di metodi equivalente alla sintassi di query. GroupBy raggruppa per dominio email. IAsyncEnumerable (C# 8) è una versione asincrona di IEnumerable, utile per il caricamento di dati in streaming nelle applicazioni mobili.

Xamarin e .NET MAUI: architettura

Xamarin (2011–2024) è stata la prima piattaforma Microsoft per lo sviluppo mobile multipiattaforma in C#. Consisteva in Xamarin.Android (runtime Mono su kernel Linux) e Xamarin.iOS (compilazione AOT in ARM64 a causa del divieto JIT su iOS). Xamarin.Forms era un livello UI condiviso con markup XAML, che traduceva gli elementi in nativi (Android View / iOS UIView).

.NET MAUI (.NET Multi-platform App UI) è il successore di Xamarin, rilasciato nel 2022. Un unico progetto .csproj, un markup XAML, un punto di ingresso. Supporta 5 piattaforme: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI utilizza la nuova architettura Handler invece di Renderer: ogni elemento XAML viene mappato su un componente nativo tramite un handler di piattaforma.

<!-- MainPage.xaml — UI dichiarativa .NET MAUI -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MyApp.MainPage">

    <ScrollView>
        <VerticalStackLayout Padding="30" Spacing="25">
            <Label Text="Welcome to .NET MAUI!"
                   FontSize="32"
                   HorizontalOptions="Center"/>

            <Entry x:Name="NameEntry"
                   Placeholder="Enter your name"/>

            <Button Text="Submit"
                    Clicked="OnSubmitClicked"
                    BackgroundColor="#512BD4"
                    TextColor="White"
                    CornerRadius="8"/>

            <CollectionView x:Name="ItemsView"
                          SelectionMode="Single">
                <CollectionView.ItemTemplate>
                    <DataTemplate>
                        <Grid Padding="10">
                            <Label Text="{Binding Name}"
                                   FontSize="18"/>
                        </Grid>
                    </DataTemplate>
                </CollectionView.ItemTemplate>
            </CollectionView>
        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

Il markup XAML di .NET MAUI descrive l'UI in modo dichiarativo. ScrollView — scorrimento, VerticalStackLayout — disposizione verticale. Label, Entry (inserimento testo), Button — elementi di base. CollectionView — lista virtualizzata con DataTemplate per visualizzare elementi. L'evento Clicked viene associato al metodo OnSubmitClicked nel code-behind MainPage.xaml.cs.

// MainPage.xaml.cs — code-behind con logica C#
namespace MyApp;

public partial class MainPage : ContentPage
{
    private readonly List<User> _users = new();

    public MainPage()
    {
        InitializeComponent();
        LoadUsers();
    }

    private async void OnSubmitClicked(object? sender, EventArgs e)
    {
        var name = NameEntry.Text?.Trim();

        if (string.IsNullOrEmpty(name))
        {
            await DisplayAlert("Error", "Name is required", "OK");
            return;
        }

        _users.Add(new User(_users.Count + 1, name, $"{name}@example.com"));
        ItemsView.ItemsSource = null;
        ItemsView.ItemsSource = _users;
        NameEntry.Text = string.Empty;
    }

    private async void LoadUsers()
    {
        var apiService = new ApiService();
        var users = await apiService.GetUsersAsync();
        _users.AddRange(users);
        ItemsView.ItemsSource = _users;
    }
}

Il code-behind MainPage eredita da ContentPage. InitializeComponent() carica il markup XAML. NameEntry.Text?.Trim() — operatore null-conditional (?.) per accesso sicuro. DisplayAlert — dialogo nativo. ItemsView.ItemsSource — Binding alla collezione. async/await per caricamento asincrono. Il pattern MVVM (Model-View-ViewModel) è raccomandato per progetti complessi.

C# nello sviluppo mobile

Lo sviluppo mobile in C# offre tre approcci: .NET MAUI (UI multipiattaforma), Xamarin (legacy) e Unity (giochi). .NET MAUI è il percorso consigliato per i nuovi progetti. L'applicazione C# viene compilata in Intermediate Language (IL), che NativeAOT (.NET MAUI) o Mono (Xamarin) trasforma in codice ARM nativo. iOS richiede compilazione AOT — JIT è vietato dalle politiche Apple.

Accesso alle API native

.NET MAUI fornisce API unificate per lavorare con le funzionalità della piattaforma tramite interfacce: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Per codice specifico della piattaforma si usa la compilazione condizionale (#if ANDROID, #if IOS) o la classe parziale.

// Geolocalizzazione in .NET MAUI con DI
public class LocationService
{
    private readonly IGeolocation _geolocation;

    public LocationService(IGeolocation geolocation)
    {
        _geolocation = geolocation;
    }

    public async Task<Location?> GetCurrentLocation()
    {
        try
        {
            var permission = await CheckAndRequestPermission();
            if (permission != PermissionStatus.Granted)
                return null;

            var location = await _geolocation.GetLastKnownLocationAsync();

            if (location == null)
            {
                location = await _geolocation.GetLocationAsync(new GeolocationRequest
                {
                    DesiredAccuracy = GeolocationAccuracy.Medium,
                    Timeout = TimeSpan.FromSeconds(10)
                });
            }

            return location;
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"Errore di posizione: {ex.Message}");
            return null;
        }
    }

    private async Task<PermissionStatus> CheckAndRequestPermission()
    {
        var status = await Permissions.CheckStatusAsync<Permissions.LocationWhenInUse>();

        if (status != PermissionStatus.Granted)
        {
            status = await Permissions.RequestAsync<Permissions.LocationWhenInUse>();
        }

        return status;
    }
}

Il servizio LocationService utilizza DI (dependency injection di IGeolocation). CheckAndRequestPermission verifica e richiede il permesso di geolocalizzazione. GetLastKnownLocationAsync — risposta rapida (non sempre precisa), GetLocationAsync — richiesta con parametri di precisione e timeout. Controlli null (location == null) con tipi di riferimento nullable. try-catch gestisce le eccezioni della piattaforma.

Prestazioni di C# sui dispositivi mobili

C# sui dispositivi mobili mostra prestazioni paragonabili a Java/Kotlin su Android e Swift su iOS. NativeAOT (.NET 8+) compila C# direttamente in codice nativo senza fase IL intermedia — questo riduce il tempo di avvio del 50% e diminuisce il consumo di memoria. Il GC in .NET MAUI è ottimizzato per piattaforme mobili con pause brevi (Workstation GC). La dimensione dell'APK è di ~20-30 MB (con NativeAOT).

Piattaforma .NET e CLR

La piattaforma .NET è un ecosistema per l'esecuzione di codice gestito, che include CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core per lo sviluppo server e .NET MAUI per applicazioni mobili. .NET 8+ è una piattaforma unificata per tutti i tipi di applicazioni: mobili, desktop, web, cloud, IoT, giochi (Unity).

CLR è una macchina virtuale che esegue codice CIL (Common Intermediate Language). C#, VB.NET, F# vengono compilati in CIL. Il compilatore JIT di CLR trasforma CIL in codice macchina alla prima chiamata del metodo. NativeAOT (compilazione anticipata) compila CIL in codice nativo al momento della build — ideale per piattaforme mobili dove JIT può essere limitato (iOS).

Il garbage collector GC di .NET è generazionale (generazioni 0, 1, 2), libera automaticamente gli oggetti inutilizzati. Per applicazioni mobili si raccomanda Workstation GC con pause minime. Il GC viene eseguito in un thread separato, senza bloccare il thread UI. Background GC è un collettore in background che minimizza le pause per applicazioni interattive.

Strumenti dello sviluppatore C#

Gli strumenti dello sviluppatore C# includono Visual Studio, .NET SDK, dotnet CLI, NuGet, JetBrains Rider. Visual Studio 2022 è l'IDE principale con designer XAML, debugger per codice gestito e nativo, profiler CPU/memoria. .NET SDK include il compilatore csc, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet è il gestore pacchetti .NET, simile a npm per JS. Oltre 300.000 pacchetti, tra cui CommunityToolkit.Maui (componenti UI), SQLite-net (database), Firebase Cloud Messaging, ZXing.Net.Maui (codici QR). .NET MAUI Community Toolkit è un insieme di comportamenti, convertitori, animazioni per accelerare lo sviluppo. RestSharp e Refit sono client HTTP. Prism e MVVM Community Toolkit sono framework architetturali.

<!-- .csproj — configurazione del progetto .NET MAUI -->
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFrameworks>net8.0-android;net8.0-ios;net8.0-maccatalyst</TargetFrameworks>
    <OutputType>Exe</OutputType>
    <UseMaui>true</UseMaui>
    <ApplicationTitle>MyMAUIApp</ApplicationTitle>
    <ApplicationId>com.example.mymauiapp</ApplicationId>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="CommunityToolkit.Maui" Version="9.0.0" />
    <PackageReference Include="sqlite-net-pcl" Version="1.9.172" />
    <PackageReference Include="Refit" Version="7.0.0" />
  </ItemGroup>

</Project>

Il file .csproj è la configurazione del progetto .NET MAUI. TargetFrameworks elenca le piattaforme di destinazione. UseMaui abilita l'SDK MAUI. PackageReference specifica le dipendenze da NuGet. CommunityToolkit.Maui fornisce componenti UI (toast, snackbar, Popup). sqlite-net-pcl è un database locale. Refit è un client HTTP tipizzato basato su interfacce. dotnet build/publish compila l'applicazione per tutte le piattaforme.