Avalonia UI : framework cross-platform pour .NET

Avalonia est un framework UI open-source et cross-platform pour .NET. Il permet de créer des applications en C# et XAML qui s'exécutent sur Windows, macOS, Linux, iOS, Android et WebAssembly depuis une seule base de code.

Sommaire

• Qu'est-ce qu'Avalonia ?
• Installation
• Exemples de code
• Déploiement Windows
• Déploiement macOS
• Support mobile (iOS & Android)

Qu'est-ce qu'Avalonia ?

Avalonia est né de la volonté de porter WPF (Windows Presentation Foundation) sur d'autres plateformes. Contrairement à .NET MAUI qui abstrait les contrôles natifs de chaque OS, Avalonia utilise son propre moteur de rendu (Skia ou Direct2D) pour dessiner chaque pixel de façon identique sur toutes les plateformes. L'application a ainsi exactement le même aspect sur Windows, macOS, Linux ou un appareil Android.

Points clés de l'architecture

• Moteur de rendu propre basé sur Skia ou Direct2D — aucun contrôle natif OS
• Couche plateforme minimale : fenêtres, événements d'entrée, presse-papiers, accélération matérielle
• Data binding, MVVM, animations et styling proches de WPF/UWP
• Basé sur .NET Standard 2.0+ (compatible .NET 8 et supérieur recommandé)
• Intégration native : Win32 APIs sur Windows, Cocoa sur macOS, X11/Wayland sur Linux

Installation

Prérequis : .NET 8 ou supérieur. Installe les templates Avalonia via la CLI dotnet, puis crée ton premier projet.

# Install Avalonia templates
dotnet new install Avalonia.Templates

# Create a desktop app
dotnet new avalonia.app -n MyApp

# Create a desktop app with MVVM pattern
dotnet new avalonia.mvvm -n MyMvvmApp

# Create a cross-platform app (Desktop + Mobile + WebAssembly)
dotnet new avalonia.xplat -n MyCrossPlatformApp

Templates disponibles

• avalonia.app — Application bureau desktop (Windows, macOS, Linux)
• avalonia.mvvm — Application bureau avec le pattern MVVM (ReactiveUI inclus)
• avalonia.xplat — Application cross-platform ciblant Bureau + Mobile + WebAssembly

IDE recommandés

• JetBrains Rider — Expérience complète sur macOS/Linux avec le plugin AvaloniaRider (prévisualisation XAML live)
• Visual Studio 2022 — Recommandé sur Windows avec l'extension Avalonia pour Visual Studio
• Visual Studio Code — Supporté mais avec des fonctionnalités limitées

Exemples de code

Interface XAML — MainWindow.axaml

Une fenêtre simple avec un champ de saisie et un bouton. La syntaxe XAML est très proche de WPF : même namespace, même mécanique de binding.

<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        x:Class="MyApp.MainWindow"
        Title="My Avalonia App"
        Width="400" Height="300">
  <StackPanel Margin="16" Spacing="8">
    <TextBlock Text="Enter your name:" />
    <TextBox Name="NameInput" Watermark="Name..." />
    <Button Content="Say Hello" Click="OnSayHelloClick" />
    <TextBlock Name="ResultText" FontWeight="Bold" />
  </StackPanel>
</Window>

Code-behind — MainWindow.axaml.cs

Gestion de l'événement click dans le code-behind. L'approche code-behind fonctionne parfaitement pour des cas simples.

using Avalonia.Controls;
using Avalonia.Interactivity;

namespace MyApp;

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void OnSayHelloClick(object sender, RoutedEventArgs e)
    {
        ResultText.Text = $"Hello, {NameInput.Text}!";
    }
}

Pattern MVVM avec ReactiveUI

Le template MVVM intègre ReactiveUI. Le ViewModel expose des propriétés observables : la vue se lie automatiquement via le binding XAML.

using ReactiveUI;

namespace MyApp.ViewModels;

public class MainWindowViewModel : ReactiveObject
{
    private string _name = string.Empty;
    private string _greeting = string.Empty;

    public string Name
    {
        get => _name;
        set => this.RaiseAndSetIfChanged(ref _name, value);
    }

    public string Greeting
    {
        get => _greeting;
        set => this.RaiseAndSetIfChanged(ref _greeting, value);
    }

    public void SayHello() => Greeting = $"Hello, {Name}!";
}

<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:vm="clr-namespace:MyApp.ViewModels"
        x:Class="MyApp.MainWindow"
        x:DataType="vm:MainWindowViewModel">
  <StackPanel Margin="16" Spacing="8">
    <TextBox Text="{Binding Name}" Watermark="Enter name..." />
    <Button Content="Say Hello" Command="{Binding SayHelloCommand}" />
    <TextBlock Text="{Binding Greeting}" FontWeight="Bold" />
  </StackPanel>
</Window>

Déploiement Windows

Sur Windows, Avalonia fonctionne dès Windows 8.1. La méthode recommandée pour la distribution est la publication en Self-Contained avec un fichier unique : l'exécutable embarque le runtime .NET et toutes les dépendances.

Commandes de publication

La publication en single file simplifie la distribution : un seul exécutable à fournir à l'utilisateur, sans installer le runtime .NET.

# Self-contained single file for Windows x64
dotnet publish -r win-x64 -c Release --self-contained true \
  -p:PublishSingleFile=true \
  -p:IncludeNativeLibrariesForSelfExtract=true

# For Windows 32-bit
dotnet publish -r win-x86 -c Release --self-contained true \
  -p:PublishSingleFile=true

Installeur avec Inno Setup ou WiX

Après publication, génère un installeur en pointant vers le dossier de sortie. Inno Setup et WiX Toolset sont les options les plus répandues pour les applications Windows .NET.

Distribution via le Microsoft Store

Avalonia supporte le packaging MSIX pour le Microsoft Store. Utilise le SDK Windows App avec la cible win10-x64, puis soumets le package via le Partner Center.

Déploiement macOS

Sur macOS, les applications Avalonia sont distribuées sous forme de bundle .app. Ce dossier suit une structure précise attendue par le système. Avalonia supporte macOS 10.14 (Mojave) et supérieur.

Structure du bundle .app

Le bundle .app contient le binaire (généré par dotnet publish), les ressources et un fichier Info.plist qui décrit l'application au système.

Publication et création du bundle

Publie pour la cible osx-arm64 (Apple Silicon) ou osx-x64 (Intel), crée manuellement la structure .app, configure Info.plist et copie les fichiers publiés.

# Publish for Apple Silicon (arm64)
dotnet publish -r osx-arm64 -c Release --self-contained true -p:UseAppHost=true

# Publish for Intel Mac (x64)
dotnet publish -r osx-x64 -c Release --self-contained true -p:UseAppHost=true

# Create the .app bundle structure
APP="MyApp.app"
mkdir -p "$APP/Contents/MacOS"
mkdir -p "$APP/Contents/Resources"
cp Info.plist "$APP/Contents/"
cp -R ./bin/Release/net8.0/osx-arm64/publish/* "$APP/Contents/MacOS/"

# Make the binary executable (required when building on non-Unix)
chmod +x "$APP/Contents/MacOS/MyApp"

# Sign with Developer ID (requires Apple Developer account)
codesign --force --timestamp --options=runtime \
  --entitlements MyApp.entitlements \
  --sign "Developer ID Application: YourName" "$APP"

Info.plist minimum

Le fichier Info.plist décrit l'application à macOS. Les clés CFBundleExecutable, CFBundleIdentifier et NSHighResolutionCapable sont indispensables.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>CFBundleName</key>
  <string>MyApp</string>
  <key>CFBundleDisplayName</key>
  <string>My Avalonia App</string>
  <key>CFBundleIdentifier</key>
  <string>com.mycompany.myapp</string>
  <key>CFBundleVersion</key>
  <string>1.0.0</string>
  <key>CFBundleShortVersionString</key>
  <string>1.0</string>
  <key>CFBundleExecutable</key>
  <string>MyApp</string>
  <key>LSMinimumSystemVersion</key>
  <string>10.14</string>
  <key>NSHighResolutionCapable</key>
  <true/>
</dict>
</plist>

Signature et notarisation

Depuis macOS 10.15 (Catalina), la signature (codesign) et la notarisation (notarytool) sont obligatoires pour distribuer une application hors App Store. Un compte Apple Developer payant est requis.

Support mobile (iOS & Android)

Avalonia supporte le développement mobile depuis la version 11. Le template avalonia.xplat génère un projet multi-cibles : un seul code UI partagé pour bureau, mobile et WebAssembly.

Compatibilité

• iOS : iOS 13 et supérieur (suit le cycle de vie MAUI pour le support .NET)
• Android : API 21 (Android 5.0 Lollipop) à API 36 (Android 16)
• Cycle de vie mobile géré nativement — intégration avec la plateforme sous-jacente

Mise en place avec le template xplat

Le template avalonia.xplat crée un projet solution avec des sous-projets ciblant Desktop, Android et iOS. La couche UI est entièrement partagée.

# Create a cross-platform project (Desktop + Mobile + WebAssembly)
dotnet new avalonia.xplat -n MyCrossPlatformApp
cd MyCrossPlatformApp

# Project structure generated:
# MyCrossPlatformApp/          <- Shared UI code
# MyCrossPlatformApp.Desktop/  <- Desktop entry point
# MyCrossPlatformApp.Android/  <- Android entry point
# MyCrossPlatformApp.iOS/      <- iOS entry point (build on macOS only)

# Run on Android
dotnet run --project MyCrossPlatformApp.Android

# Run on iOS (requires macOS + Xcode)
dotnet run --project MyCrossPlatformApp.iOS

Points d'attention

• Le support mobile est plus récent que le support bureau — vérifier la disponibilité des contrôles avancés
• La signature iOS nécessite un Mac avec Xcode installé
• MAUI reste l'option officiellement supportée par Microsoft pour des contrôles 100% natifs
• Évaluer les performances Skia sur les appareils cibles avant de commencer