RIP les Value Converters ? Ce que changent vraiment les expressions C# dans XAML

Si tu développes avec XAML, que ce soit avec Windows Presentation Foundation(WPF), .NET MAUI tu as forcément déjà utilisé des Value Converters.

Pendant des années, ils ont été indispensables pour adapter les données à l’interface utilisateur :

• formater un prix
• transformer un booléen en texte
• gérer une couleur dynamique
• contrôler la visibilité

Mais avec le temps, une frustration est apparue :

Beaucoup de transformations sont simples mais nécessitent beaucoup de code.

Créer une classe, l’enregistrer dans les ressources, la référencer dans le XAML… tout ça pour une simple condition.

Et si tout cela pouvait disparaître ?

Une évolution en cours : les expressions C# dans XAML

Une proposition récente dans l’écosystème .NET introduit la possibilité d’écrire des expressions C# directement dans le XAML.

Source officielle : [dotnet/maui pull request 33693](http://dotnet/maui pull request 33693)

Cette initiative, encore expérimentale, explore une nouvelle façon d’écrire les bindings.

Exemples :

<Label Text="{IsActive ? 'Actif' : 'Inactif'}" />

<Label Text="{$'{Price:C2}'}" />

<Label Text="{Price * Quantity}" />

Objectif :

• réduire le boilerplate
• améliorer la lisibilité
• rapprocher XAML du C#

Pourquoi certains parlent de RIP Converters

Une phrase a circulé dans la communauté :

“ RIP converters — C# expressions in XAML are here “

Elle traduit une réalité simple :

Dans de nombreux cas, les converters deviennent inutiles.

Avant

<Label Text="{Binding IsActive, Converter={StaticResource BoolToStatusConverter}}" />

Après

<Label Text="{IsActive ? 'Actif' : 'Inactif'}" />

Résultat :

• moins de code
• moins de fichiers
• moins de complexité

Pourquoi les Value Converters existent toujours

Il est essentiel de rester précis :

les Value Converters ne disparaissent pas.

Ils restent indispensables pour :

• une logique complexe
• la réutilisation entre plusieurs vues
• la testabilité
• les transformations avancées

Documentation officielle : https://learn.microsoft.com/dotnet/maui/fundamentals/data-binding/

Prenons un cas, avec quelques extraits des codes

Modèle

public class Product
{
  public string Name { get; set; }
  public decimal Price { get; set; }
  public int Quantity { get; set; }
  public bool IsAvailable { get; set; }
}

Avant (avec converters)

<Label Text="{Binding Price, Converter={StaticResource PriceConverter}}" />
<Label Text="{Binding ., Converter={StaticResource TotalConverter}}" />
<Label Text="{Binding IsAvailable, Converter={StaticResource AvailabilityConverter}}" />
<TextColor="{Binding IsAvailable, Converter={StaticResource AvailabilityColorConverter}}" />

Problème : trop de dépendances pour des transformations simples.

Après (avec expressions C#)

<Label Text="{$'{Price:C2}'}" />
<Label Text="{Price * Quantity}" />
<Label Text="{IsAvailable ? 'Disponible' : 'Rupture'}" />
<TextColor="{IsAvailable ? Colors.Green : Colors.Red}" />

Résultat final

<CollectionView ItemsSource="{Binding Products}">
  <CollectionView.ItemTemplate>
    <DataTemplate>
      <VerticalStackLayout Padding="10">
        <Label Text="{Name}" />
        <Label Text="{$'{Price:C2}'}" />
        <Label Text="{Price * Quantity}" />
        <Label Text="{IsAvailable ? 'Disponible' : 'Rupture'}" TextColor="{IsAvailable ? Colors.Green : Colors.Red}" />
        <Label Text="{$'{Quantity} x {Name}'}" />
      </VerticalStackLayout>
    </DataTemplate>
  </CollectionView.ItemTemplate>
</CollectionView>

Bénéfices :

• code plus direct
• meilleure lisibilité
• moins de maintenance

Limites et statut actuel

Point essentiel :

Cette fonctionnalité est expérimentale.

Selon la proposition dans dotnet/maui pull request 33693 :

• elle repose sur des concepts comme les source generators
• elle n’est pas encore officiellement documentée comme feature stable

Conclusion objective :

ce n’est pas encore prêt pour tous les projets en production.

Conclusion

Les expressions C# dans XAML ne suppriment pas les Value Converters.

Elles changent surtout une chose :

le réflexe de les utiliser pour des cas simples.

Pour les besoins simples comme les conditions, le formatage ou les calculs, elles réduisent considérablement le code tout en améliorant la lisibilité.

Mais dès que la logique devient complexe, réutilisable ou testable, les converters restent une solution adaptée.

Cette évolution s’inscrit dans une tendance claire de l’écosystème .NET :

réduire le boilerplate, améliorer la productivité, et rapprocher XAML du langage C#.

La vraie question n’est donc pas :

Les converters vont-ils disparaître ?

Mais plutôt :

Quel est le bon outil pour ce besoin précis ?

Références

• dotnet/maui pull request 33693

https://github.com/dotnet/maui/pull/33693

• Microsoft — Data Binding (.NET MAUI)

https://learn.microsoft.com/dotnet/maui/fundamentals/data-binding/

• .NET MAUI — Documentation officielle

https://learn.microsoft.com/dotnet/maui/