Xamarin — qu'est-ce que c'est, plateformes et développement en C#

Qu'est-ce que Xamarin

Xamarin est une plateforme basée sur .NET et Mono qui permet d'utiliser C# pour créer des applications mobiles multiplateformes. La société Xamarin a été fondée en 2011 et rachetée par Microsoft en 2016 pour 400 millions de dollars. Après l'acquisition, Xamarin est devenu partie intégrante de l'écosystème Visual Studio et Azure.

Avant l'acquisition, Xamarin était un produit commercial avec une licence Enterprise. Microsoft l'a rendu gratuit dans le cadre de Visual Studio Community et a également ouvert le code source de Mono Runtime et des bindings SDK. Cela a conduit à une augmentation de popularité : en 2020, Xamarin était utilisé dans 15 % des projets multiplateformes, selon un rapport de SlashData.

L'idée principale de Xamarin est de diviser le code en trois couches : la logique métier partagée (C#, .NET Standard), les projets spécifiques à la plateforme (iOS, Android) et une UI partagée optionnelle via Xamarin.Forms. Cette approche permettait de réutiliser jusqu'à 75 % du code tout en conservant un accès natif aux API de chaque plateforme.

Histoire et évolution de Xamarin

La première version Xamarin 1.0 est sortie en 2012 avec le support d'iOS uniquement. Le support d'Android a été ajouté en 2013. Xamarin.Forms — un framework d'UI déclaratif — a été présenté en 2014 lors de la conférence Evolve. Xamarin 4.0 (2016) incluait le support de watchOS et tvOS. Xamarin 5.0 (2019) a introduit les styles CSS et le thème Material Design.

La dernière version majeure Xamarin.Forms 5.0 est sortie en 2021. Microsoft a annoncé que Xamarin passait en mode support (fin de vie — 1er mai 2024) et a recommandé la migration vers .NET MAUI (Multi-platform App UI), qui fait partie de .NET 6+. Xamarin.Forms 5.0 ne reçoit plus de nouvelles fonctionnalités, seulement des correctifs de sécurité critiques.

Xamarin.Forms vs Xamarin.Native

Xamarin.Forms est un framework d'UI qui abstrait l'interface via un ensemble unifié de composants. Le balisage XAML (ContentPage, StackLayout, Label, Button) est mappé aux contrôles natifs de chaque plateforme via des renderers. Label est traduit en UILabel sur iOS et en TextView sur Android. Cette approche fournit jusqu'à 95 % de code UI partagé.

Xamarin.Native (également Xamarin.iOS et Xamarin.Android) est une approche sans UI partagée. Le développeur crée des écrans séparés pour iOS (Interface Builder ou Storyboard) et Android (AXML), en utilisant un seul backend C#. Cela donne un contrôle total sur l'apparence de chaque plateforme mais augmente la duplication du code UI à 50–60 %.

Selon l'Enquête Développeurs Microsoft 2023, 70 % des projets Xamarin utilisaient Xamarin.Forms, 20 % utilisaient Xamarin.Native avec des services partagés et 10 % utilisaient une approche hybride avec des renderers personnalisés pour des optimisations spécifiques à la plateforme.

Architecture de Xamarin

L'architecture de Xamarin se compose de deux niveaux. Le niveau inférieur est Mono Runtime, qui exécute le C# IL (Intermediate Language) sur la plateforme. Le niveau supérieur est constitué de Managed Callable Wrappers (MCW) pour iOS et d'Android Bindings pour Android, qui fournissent l'accès aux API natives à partir du code géré C#.

Mono Runtime et bindings de plateforme

Mono est une implémentation open source du .NET Framework. Dans Xamarin, Mono fonctionne comme le Common Language Runtime (CLR), chargeant les assemblys C# et les compilant en code machine. Sur iOS, Mono compile Ahead-of-Time (AOT) — en code machine ARM64, car Apple interdit la compilation JIT dans les applications utilisateur. Sur Android, Mono utilise la compilation JIT avec du profilage AOT.

Les bindings iOS (Xamarin.iOS) sont des wrappers C# autour du runtime Objective-C. Chaque classe UIKit (UIView, UIViewController) est représentée par une classe gérée dans l'assembly Xamarin.iOS.dll. Les sélecteurs Objective-C sont invoqués via le mécanisme MessageUI. Sur Android, Xamarin.Android utilise Android Callable Wrappers (ACW) — un pont JNI entre C# et Java/Kotlin. Les bibliothèques Kotlin sont encapsulées via Android Bindings Library.

XAML et C# dans Xamarin

XAML (eXtensible Application Markup Language) est un langage déclaratif pour décrire l'UI. Dans Xamarin.Forms, le XAML définit la structure de l'écran : pages (ContentPage), conteneurs (StackLayout, Grid, FlexLayout) et éléments (Label, Entry, Button, ListView). Le code-behind en C# gère les événements (Clicked, PropertyChanged) et la liaison de données (Binding, Data Binding).

Le modèle MVVM est l'architecture recommandée pour Xamarin.Forms. Le modèle (Model) contient les données, la ViewModel implémente INotifyPropertyChanged et les commandes (ICommand), et la vue (XAML) se lie via BindingContext. L'implémentation d'ICommand via RelayCommand ou Prism DelegateCommand permet de tester la ViewModel sans dépendances UI. La bibliothèque Prism.Forms fournit NavigationService, DialogService et la modularité.

Exemple d'application Xamarin.Forms

using Xamarin.Forms;

namespace XamarinApp
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();
            
            var label = new Label
            {
                Text = "Hello, Xamarin!",
                FontSize = 24,
                VerticalOptions = LayoutOptions.Center,
                HorizontalOptions = LayoutOptions.Center
            };
            
            Content = new StackLayout
            {
                Children = { label }
            };
        }
    }
}

Avantages et inconvénients de Xamarin

Langage C# unifié — le principal avantage de Xamarin. Les développeurs C# et .NET peuvent créer des applications mobiles sans apprendre Swift, Kotlin ou Objective-C. La logique métier, la mise en réseau, les bases de données (SQLite via ORM), le chiffrement et la journalisation sont écrits une fois et réutilisés sur toutes les plateformes. Cela simplifie la maintenance et les tests du code.

Accès aux API natives — Xamarin fournit un accès à 100 % aux API iOS (Cocoa Touch) et Android (Android SDK) via des bindings. Lorsqu'une nouvelle version d'iOS ou d'Android est publiée, Microsoft publie des bindings mis à jour dans les 24 à 48 heures. Pour les bindings manquants (bibliothèques Objective-C ou Kotlin personnalisées), on crée manuellement Android Bindings Library ou iOS Binding Library.

Intégration avec l'écosystème Microsoft — Xamarin prend en charge Visual Studio, Azure DevOps, App Center (CI/CD, tests, surveillance) et Enterprise Mobility + Security (Intune, ADAL, MSAL). App Center Analytics et Crashes collectent des données à partir d'applications en direct. Visual Studio App Center automatise la compilation, les tests sur appareil et la publication dans les magasins d'applications.

Inconvénients de Xamarin incluent la taille de l'application — un APK Xamarin.Forms avec écran vide pèse 25 à 35 Mo contre 5 à 8 Mo pour une application Android native. Le temps de compilation est également plus long : un projet de taille moyenne se compile en 2 à 5 minutes contre 30 à 60 secondes dans Android Studio natif. Mono Runtime ajoute 15 à 20 Mo au binaire final.

Le deuxième inconvénient est le retard des nouvelles API. Les nouvelles fonctionnalités iOS/Android apparaissent immédiatement dans le développement natif, tandis que dans Xamarin, elles arrivent 1 à 2 mois après la publication des bindings. Le SDK iOS 17 (2023) était entièrement pris en charge par Xamarin 3 semaines après sa sortie. Pour les projets urgents, cela peut être critique. .NET MAUI résout ce problème grâce à l'intégration directe avec .NET 8.

Migration vers .NET MAUI

.NET MAUI (Multi-platform App UI) est l'évolution de Xamarin.Forms, publiée par Microsoft en 2022 avec .NET 6. MAUI unifie iOS, Android, Windows et macOS en un seul projet sans projets séparés pour chaque plateforme. Contrairement à Xamarin.Forms, MAUI utilise .NET 6+ BCL au lieu de Mono et .NET Standard.

Microsoft fournit un outil de migration — .NET Upgrade Assistant pour Visual Studio. Il analyse le projet Xamarin.Forms, remplace les espaces de noms (Xamarin.Forms.* -> Microsoft.Maui.*), met à jour les fichiers .csproj (format style SDK) et migre les paramètres Android et iOS vers une configuration unifiée. Après la migration, le projet peut tirer parti de toutes les nouvelles capacités de .NET 8 : Native AOT, CodeQL pour la sécurité et des performances de compilation améliorées.

Le changement clé est un projet unique. Alors que Xamarin.Forms nécessitait 3 projets séparés (iOS, Android, .NET Standard), .NET MAUI utilise un seul projet avec les dossiers Platforms/iOS, Platforms/Android, Platforms/Windows et Platforms/MacCatalyst. Chaque plateforme compile à partir de code partagé avec des directives conditionnelles spécifiques à la plateforme (#if ANDROID, #if IOS).

Pour les bases de code existantes, .NET MAUI maintient 90 % de compatibilité ascendante avec Xamarin.Forms. La compatibilité des API couvre ContentView, ContentPage, Shell, NavigationPage, DependencyService et MessagingCenter. Les principaux changements ont affecté Device.StartTimer (remplacé par IDispatcher), Platform API (déplacé vers Microsoft.Maui.ApplicationModel) et les renderers obsolètes (remplacés par Handlers).

Le processus de migration comprend cinq étapes. Premièrement — mettre à jour Xamarin.Forms vers la dernière version 5.0. Deuxièmement — remplacer .NET Standard 2.0 par .NET 6 ou 8. Troisièmement — exécuter Upgrade Assistant pour la conversion automatique du projet. Quatrièmement — corriger le code spécifique à la plateforme dans les dossiers Platforms. Cinquièmement — tester, en particulier les renderers personnalisés et les services de plateforme.