Skip to content
← Tous les articles
· Delta1 Labs MVVMNebula

Comment le renommage casse les bindings de MVVM Toolkit

CommunityToolkit.Mvvm transforme un champ marqué [ObservableProperty] en propriété publique et une méthode marquée [RelayCommand] en commande, et XAML se lie à ces noms générés par chaîne. Cet article lit l'IL généré pour montrer quels noms un binding résout sous forme de chaîne — et qu'il faut conserver — par rapport à ceux que le générateur a câblés comme délégué ou token direct, qui se renomment sans problème. Puis il cadre Nebula pour conserver les premiers et obfusquer tout le reste.

Un view-model CommunityToolkit.Mvvm est en grande partie du code que vous n’avez jamais écrit. Vous déclarez un champ et un attribut ; un générateur de source produit la propriété publique, la plomberie PropertyChanged et l’objet commande à la compilation. C’est l’attrait — et c’est aussi pourquoi obfusquer une telle application fait trébucher. Les noms auxquels XAML se lie ne sont pas dans votre source. Ils sont générés, ils sont publics, et certains se résolvent par chaîne à l’exécution tandis que d’autres en ont seulement l’air.

La vraie question

Quand vous renommez un assembly, la vraie question n’est jamais « le binding va-t-il casser » — c’est « lequel de ces noms générés le runtime recherche-t-il par sa chaîne, et lequel le générateur a-t-il déjà câblé comme référence directe ? ». Le premier ensemble doit être conservé. Le second se renomme sans effet. Réussissez cette distinction et vous obfusquez une application MVVM Toolkit aussi fort que n’importe quelle autre ; ratez-la et vous divulguez toute la surface du view-model ou livrez des contrôles morts. La distinction est visible dans l’IL généré, alors lisons-le.

Ce que le générateur produit

Commençons par un petit view-model écrit à la manière de MVVM Toolkit.

public partial class CustomerViewModel : ObservableObject
{
    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(DisplayName))]
    private string _firstName = "";

    public string DisplayName => $"Customer: {FirstName}";

    [RelayCommand(CanExecute = nameof(CanSave))]
    private void Save() { /* persist */ }

    private bool CanSave() => FirstName.Length > 0;
}

Le générateur émet une classe partielle qui le complète. Réduite à ce qui compte, la propriété générée ressemble à ceci :

partial class CustomerViewModel
{
    public string FirstName
    {
        get => _firstName;
        set
        {
            if (!EqualityComparer<string>.Default.Equals(_firstName, value))
            {
                OnPropertyChanging("FirstName");
                _firstName = value;
                OnPropertyChanged("FirstName");
                OnPropertyChanged("DisplayName");   // from NotifyPropertyChangedFor
            }
        }
    }

    private RelayCommand? saveCommand;
    public IRelayCommand SaveCommand =>
        saveCommand ??= new RelayCommand(Save, CanSave);   // direct delegates
}

(Le générateur réel achemine les notifications de changement via des instances PropertyChangedEventArgs mises en cache pour des raisons d’allocation, mais le contenu de la chaîne est exactement celui que vous voyez.) Deux sortes de noms vivent désormais dans cet IL, et ils se comportent de façon totalement différente face au renommage.

Chaînes et tokens

Le getter et le setter atteignent le champ de stockage avec ldfld/stfld contre un token de champ :

IL_0001:  ldarg.0
IL_0002:  ldfld      string MyApp.CustomerViewModel::_firstName

Ce token pointe vers la ligne FieldDef, pas vers le texte _firstName. Renommez le champ en a et Nebula réécrit la ligne ; le ldfld se résout toujours. Le nom du champ est libre.

La notification, en revanche, porte une véritable constante de chaîne :

IL_0014:  ldarg.0
IL_0015:  ldstr      "FirstName"
IL_001a:  call       instance void ...ObservableObject::OnPropertyChanged(string)

Ce ldstr "FirstName" est le nom que le moteur de binding de WPF tentera de faire correspondre. Quand XAML dit {Binding FirstName}, le moteur parcourt les propriétés du type du DataContext par nom via PropertyDescriptor/réflexion, trouve une propriété littéralement nommée FirstName, s’abonne à PropertyChanged et filtre les notifications en comparant la chaîne PropertyName de l’événement. Renommez la propriété en a et trois choses tournent mal à la fois : la recherche de chemin ne trouve rien, le binding signale une erreur de chemin et retombe sur une valeur par défaut, et la chaîne OnPropertyChanged("FirstName") ne nomme plus rien que l’interface écoute. Le tout en silence.

La commande, c’est la même histoire avec une subtilité supplémentaire. SaveCommand est une propriété publique, donc {Binding SaveCommand} la résout par chaîne exactement comme FirstName : conservez-la. Mais le prédicat CanSave à l’intérieur est un délégué, passé comme new RelayCommand(Save, CanSave). Le générateur a résolu nameof(CanSave) à la compilation et émis une référence de méthode directe ; il n’y a aucune chaîne "CanSave" nulle part à l’exécution. CanSave se renomme sans problème, et Save aussi. Le seul nom lié à la commande qui regarde vers la couche de binding est SaveCommand lui-même.

Résolus par CHAÎNE — à conserverFirstNamepropriété générée — {Binding FirstName}DisplayNameNotifyPropertyChangedFor → ldstr "DisplayName"SaveCommandcommande générée — {Binding SaveCommand}le moteur de binding les associe par nompar réflexion — renommer change le contratCâblés par TOKEN / délégué — libres_firstNamechamp de stockage — ldfld par tokenCanSavedélégué CanExecute — réf directeSavecible de la commande — par déléguéOnFirstNameChangedhooks partiels — appelés, non nommés

La keep-list s’écrit donc toute seule : les propriétés publiques et les commandes générées sur chaque view-model, plus toute propriété nommée dans un [NotifyPropertyChangedFor] (son nameof devient un ldstr à l’exécution). Tout le reste produit par le générateur — champs de stockage, prédicats CanExecute, méthodes cibles de commande, hooks partiels OnXxxChanged/OnXxxChanging — est référencé par token ou par délégué et se renomme sans effet sur le binding.

Cadrer Nebula

Comme les membres générés qu’il faut conserver sont exactement la surface publique de vos view-models, une seule règle keep cadrée sur les membres l’exprime avec précision.

{
  "schemaVersion": 1,
  "inputs": ["bin/Release/net8.0/MyApp.dll"],
  "outputDirectory": "protected",
  "encryptStrings": true,
  "controlFlowObfuscation": true,
  "renaming": {
    "rules": [
      { "pattern": "MyApp.ViewModels.*", "action": "keep", "members": "public" },
      { "pattern": "MyApp.*",            "action": "rename" }
    ]
  }
}

La première règle conserve les noms de propriété et de commande publics sur chaque view-model — les FirstName, DisplayName et SaveCommand générés — et le qualificateur members: "public" laisse le champ privé _firstName, le prédicat CanSave, la méthode Save et les hooks partiels se renommer normalement. La seconde règle renomme tout le reste de l’assembly : vos services, votre couche de persistance, votre logique métier. Et l’essentiel : un keep est uniquement sur le nom — les view-models conservés gardent leurs corps de méthode obfusqués par contrôle de flux et leurs littéraux de chaîne chiffrés. Vous renoncez au renommage sur une poignée de noms tournés vers le binding, pas à la protection du code derrière.

Si vous préférez ne pas raisonner sur le namespace qui contient les view-models, preservePublicApi: true conserve toute la surface visible de l’extérieur et obtient le même résultat pour tout view-model public — au prix de conserver aussi les noms de tous les autres types publics. Pour une application de bureau livrée sans consommateurs de bibliothèque, la règle cadrée par namespace ci-dessus divulgue moins.

Mises en garde et cas de rupture

Le mode de défaillance est silencieux. Une propriété liée renommée ne lève pas d’exception — WPF et WinUI consignent un BindingExpression path error dans la trace de débogage et laissent le contrôle à sa valeur de repli. Un test de fumée qui se contente de lancer l’application et de voir une fenêtre passera alors que la moitié des champs sont vides. Le seul test d’acceptation honnête est d’exécuter la version protégée et de parcourir les écrans avec bindings, en surveillant dans la sortie de débogage une erreur de chemin qui nomme le membre renommé.

Deux cas limites méritent d’être signalés. D’abord, si un view-model est internal plutôt que public — certaines équipes les gardent internes et ne les exposent que via une interface —, alors members: "public" ne le couvre pas et preservePublicApi non plus ; les propriétés générées restent des membres publics d’un type non public, et vous devez conserver ce view-model explicitement. Ensuite, [ObservableProperty] appliqué à un champ dont le nom alimente une propriété calculée via [NotifyPropertyChangedFor] crée une dépendance que vous pouvez manquer : la propriété calculée DisplayName doit aussi être conservée, car son nom voyage sous forme de chaîne à l’exécution dans le setter et l’interface s’y lie. Conserver tous les membres publics du view-model, comme ci-dessus, couvre les deux sans que vous ayez à les énumérer.

Et la règle de base sous tout cela : il s’agit de protéger la propriété intellectuelle de votre propre application. Conservez les noms que la couche de binding résout par chaîne et obfusquez la logique devant laquelle ces bindings se trouvent.

À retenir

Le générateur MVVM Toolkit émet deux sortes de noms dans votre assembly, et le renommage les traite à l’opposé. Les noms tournés vers la couche de binding — les propriétés publiques générées, les commandes et toute propriété levée via [NotifyPropertyChangedFor] — vivent comme des chaînes à l’exécution et doivent survivre. Les noms câblés comme tokens de métadonnées ou délégués directs — champs de stockage, prédicats CanExecute, cibles de commande, hooks partiels — se renomment sans problème. Un keep members: "public" sur le namespace de vos view-models trace exactement cette ligne, et c’est pourquoi obfusquer une application CommunityToolkit.Mvvm est un problème de cadrage, pas une raison d’éviter l’obfuscation. Nebula.NET conserve le contrat de binding et obfusque tout ce qui est derrière ; ouvrez le résultat dans Glass.NET pour confirmer que les noms publics de vos view-models ont survécu tandis que les internes se lisent comme a, b, c.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.