C# : concepts clés du langage, développement .NET MAUI et Xamarin

Qu'est-ce que C# ?

C# (prononcé « si sharp ») est un langage de programmation orienté objet avec un système de types sûr, développé par Microsoft en 2000 sous la direction d'Anders Hejlsberg. Le nom s'inspire de la notation musicale (dièse — élévation de la tonalité). C# fonctionne sur la plateforme .NET, qui inclut le Common Language Runtime (CLR) et une vaste bibliothèque de classes (BCL — Base Class Library).

Dans le développement mobile, C# est utilisé via deux technologies : Xamarin (2011–2024) et son successeur .NET MAUI (2022+). Xamarin permettait de créer des applications natives Android et iOS avec du code C# partagé, en séparant les projets spécifiques à chaque plateforme. .NET MAUI combine toutes les plateformes en un seul projet avec un balisage XAML partagé et un accès aux API natives via des interfaces de plateforme.

Une caractéristique clé de C# est le typage statique strict avec possibilité de dispatch dynamique via dynamic, le mot-clé var (inférence de type) et un puissant système de génériques. C# est un langage entièrement géré : la mémoire est gérée par le ramasse-miettes (GC), les limites des tableaux sont vérifiées, les variables non initialisées sont interdites. Cela rend C# plus sûr que C++ avec des performances comparables grâce à la compilation AOT.

Versions de C# et évolution

C# 1.0 (2000) — langage OOP de base. C# 3.0 (2007) — LINQ, expressions lambda, méthodes d'extension. C# 6.0 (2015) — interpolation de chaînes, opérateur null-conditionnel. C# 8.0 (2019) — types de référence nullables (activation de la sécurité null), flux asynchrones, méthodes d'interface par défaut. C# 10 (2021) — directives using globales, espaces de noms par fichier, record struct. C# 12 (2023) — constructeurs primaires, expressions de collection, intercepteurs. Chaque version apporte des améliorations pertinentes pour le développement mobile.

Syntaxe C# : types, classes et LINQ

La syntaxe C# est de type C, strictement typée. Tout est un objet, y compris les primitifs (int, double, bool — ce sont des structures héritant de ValueType). C# divise les types en types valeur (int, double, bool, struct, enum — stockés sur la pile) et types référence (string, class, interface, delegate, array, record — stockés sur le tas). Les types nullables (int?) autorisent null pour les types valeur.

Types de données et classes

C# prend en charge les classes (class), les structures (struct), les enregistrements (record), les interfaces (interface), les énumérations (enum) et les délégués (delegate). record est un type référence immuable avec égalité basée sur la valeur (deux enregistrements sont égaux si tous leurs champs sont égaux). record struct est la version valeur de record, introduite en C# 10. Les constructeurs primaires (C# 12) combinent déclaration et initialisation en une seule ligne.

// Types et classes de base en C#
using System;
using System.Collections.Generic;

// Enregistrement avec constructeur primaire (C# 12)
public record User(int Id, string Name, string Email);

// Classe avec propriétés nullables
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

    // Méthode avec corps d'expression
    public string GetDisplayName() => $"{AppName} v{Version}";
}

// Méthode d'extension
public static class StringExtensions
{
    public static bool IsValidEmail(this string email) =>
        email.Contains("@") && email.Contains(".");
}

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

L'enregistrement User avec constructeur primaire génère automatiquement equals, hashCode, ToString, Deconstruct et la copie avec. Les setters init-only (AppName) permettent de définir une valeur uniquement dans l'initialiseur. Le corps d'expression (=>) est une notation concise pour les méthodes simples. La méthode d'extension IsValidEmail ajoute une méthode à string sans héritage.

LINQ — Language Integrated Query

LINQ est un langage de requête intégré pour les collections, les bases de données, XML. LINQ to Objects — requêtes sur les collections IEnumerable. LINQ to SQL — sur les bases de données. LINQ to XML — sur XML. La syntaxe peut être de requête (from u in users where u.Age > 18 select u) et de méthode (users.Where(u => u.Age > 18).Select(u => u)). Chargement différé (exécution différée) : la requête s'exécute à l'itération, pas à la déclaration.

// Requêtes LINQ sur les collections
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"),
};

// Syntaxe de requête
var filteredUsers = from u in users
                     where u.Email.Contains("example")
                     orderby u.Name
                     select u;

// Syntaxe de méthode avec plusieurs opérations
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

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

// LINQ avec flux asynchrone (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 requête LINQ filteredUsers filtre les utilisateurs par domaine d'email et trie par nom. La syntaxe de méthode .Where().OrderBy().Select() est une chaîne de méthodes équivalente à la syntaxe de requête. GroupBy groupe par domaine d'email. IAsyncEnumerable (C# 8) est une version asynchrone d'IEnumerable, utile pour le chargement de données en flux dans les applications mobiles.

Xamarin et .NET MAUI : architecture

Xamarin (2011–2024) était la première plateforme de Microsoft pour le développement mobile multiplateforme en C#. Il se composait de Xamarin.Android (runtime Mono sur noyau Linux) et Xamarin.iOS (compilation AOT vers ARM64 en raison de l'interdiction du JIT sur iOS). Xamarin.Forms était une couche d'interface utilisateur partagée avec balisage XAML, traduisant les éléments en natifs (Android View / iOS UIView).

.NET MAUI (.NET Multi-platform App UI) est le successeur de Xamarin, sorti en 2022. Un seul projet .csproj, un balisage XAML, un point d'entrée. Prend en charge 5 plateformes : iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI utilise la nouvelle architecture Handler au lieu de Renderer : chaque élément XAML est mappé à un composant natif via un gestionnaire de plateforme.

<!-- MainPage.xaml — interface utilisateur déclarative .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>

Le balisage XAML de .NET MAUI décrit l'interface utilisateur de manière déclarative. ScrollView — défilement, VerticalStackLayout — disposition verticale. Label, Entry (saisie de texte), Button — éléments de base. CollectionView — liste virtualisée avec DataTemplate pour afficher les éléments. L'événement Clicked est lié à la méthode OnSubmitClicked dans le code-behind MainPage.xaml.cs.

// MainPage.xaml.cs — code-behind avec logique 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;
    }
}

Le code-behind MainPage hérite de ContentPage. InitializeComponent() charge le balisage XAML. NameEntry.Text?.Trim() — opérateur null-conditionnel (?.) pour un accès sécurisé. DisplayAlert — boîte de dialogue native. ItemsView.ItemsSource — liaison à la collection. async/await pour le chargement asynchrone. Le modèle MVVM (Model-View-ViewModel) est recommandé pour les projets complexes.

C# dans le développement mobile

Le développement mobile en C# offre trois approches : .NET MAUI (interface utilisateur multiplateforme), Xamarin (hérité) et Unity (jeux). .NET MAUI est la voie recommandée pour les nouveaux projets. L'application C# est compilée en Intermediate Language (IL), que NativeAOT (.NET MAUI) ou Mono (Xamarin) transforme en code ARM natif. iOS nécessite une compilation AOT — le JIT est interdit par les politiques d'Apple.

Accès aux API natives

.NET MAUI fournit des API unifiées pour travailler avec les capacités de la plateforme via des interfaces : IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Pour le code spécifique à une plateforme, on utilise la compilation conditionnelle (#if ANDROID, #if IOS) ou une classe partielle.

// Géolocalisation dans .NET MAUI avec 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($"Erreur de localisation : {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;
    }
}

Le service LocationService utilise DI (injection de dépendance de IGeolocation). CheckAndRequestPermission vérifie et demande l'autorisation de géolocalisation. GetLastKnownLocationAsync — réponse rapide (pas toujours précise), GetLocationAsync — demande avec paramètres de précision et de délai d'attente. Vérifications null (location == null) avec les types de référence nullables. try-catch gère les exceptions de la plateforme.

Performances de C# sur mobile

C# sur les appareils mobiles offre des performances comparables à Java/Kotlin sur Android et Swift sur iOS. NativeAOT (.NET 8+) compile C# directement en code natif sans étape IL intermédiaire — cela réduit le temps de démarrage de 50 % et diminue la consommation mémoire. Le GC dans .NET MAUI est optimisé pour les plateformes mobiles avec de courtes pauses (Workstation GC). La taille de l'APK est d'environ 20-30 Mo (avec NativeAOT).

Plateforme .NET et CLR

La plateforme .NET est un écosystème d'exécution de code géré, comprenant CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core pour le développement serveur et .NET MAUI pour les applications mobiles. .NET 8+ est une plateforme unifiée pour tous les types d'applications : mobiles, desktop, web, cloud, IoT, jeux (Unity).

CLR est une machine virtuelle qui exécute le code CIL (Common Intermediate Language). C#, VB.NET, F# sont compilés en CIL. Le compilateur JIT du CLR transforme le CIL en code machine au premier appel de méthode. NativeAOT (compilation anticipée) compile le CIL en code natif au moment de la construction — idéal pour les plateformes mobiles où le JIT peut être restreint (iOS).

Le ramasse-miettes GC de .NET est générationnel (générations 0, 1, 2), libère automatiquement les objets inutilisés. Pour les applications mobiles, Workstation GC avec des pauses minimales est recommandé. Le GC s'exécute dans un thread séparé, sans bloquer le thread d'interface utilisateur. Background GC est un collecteur d'arrière-plan qui minimise les pauses pour les applications interactives.

Outils du développeur C#

Les outils du développeur C# incluent Visual Studio, le SDK .NET, dotnet CLI, NuGet, JetBrains Rider. Visual Studio 2022 est l'IDE principal avec concepteur XAML, débogueur de code géré et natif, profileur CPU/mémoire. Le SDK .NET inclut le compilateur csc, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet est le gestionnaire de paquets .NET, similaire à npm pour JS. Plus de 300 000 paquets, dont CommunityToolkit.Maui (composants d'interface utilisateur), SQLite-net (base de données), Firebase Cloud Messaging, ZXing.Net.Maui (codes QR). .NET MAUI Community Toolkit est un ensemble de comportements, convertisseurs et animations pour accélérer le développement. RestSharp et Refit sont des clients HTTP. Prism et MVVM Community Toolkit sont des frameworks architecturaux.

<!-- .csproj — configuration du projet .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>

Le fichier .csproj est la configuration du projet .NET MAUI. TargetFrameworks énumère les plateformes cibles. UseMaui active le SDK MAUI. PackageReference spécifie les dépendances NuGet. CommunityToolkit.Maui fournit des composants d'interface utilisateur (toasts, snackbars, Popup). sqlite-net-pcl est une base de données locale. Refit est un client HTTP typé basé sur des interfaces. dotnet build/publish construit l'application pour toutes les plateformes.