Skip to content
← Alle Beiträge
· Delta1 Labs MVVMNebula

Wie Umbenennung MVVM-Toolkit-Bindings zerstört

CommunityToolkit.Mvvm macht aus einem Feld mit [ObservableProperty] eine öffentliche Eigenschaft und aus einer Methode mit [RelayCommand] ein Command, und XAML bindet per Zeichenkette an diese generierten Namen. Dieser Beitrag liest das generierte IL, um zu zeigen, welche Namen ein Binding als Zeichenkette auflöst — und die behalten werden müssen — gegenüber jenen, die der Generator als direkten Delegaten oder Token verdrahtet hat und die sich problemlos umbenennen lassen. Danach grenzt er Nebula so ein, dass die ersten erhalten bleiben und alles andere obfuskiert wird.

Ein CommunityToolkit.Mvvm-View-Model besteht größtenteils aus Code, den Sie nie geschrieben haben. Sie deklarieren ein Feld und ein Attribut; ein Source-Generator erzeugt die öffentliche Eigenschaft, die PropertyChanged-Verrohrung und das Command-Objekt zur Kompilierzeit. Das ist der Reiz — und zugleich der Grund, warum das Obfuskieren einer solchen App Stolpersteine birgt. Die Namen, an die XAML bindet, stehen nicht in Ihrem Quellcode. Sie sind generiert, sie sind öffentlich, und manche werden zur Laufzeit per Zeichenkette aufgelöst, während andere nur so aussehen.

Die eigentliche Frage

Wenn Sie ein Assembly umbenennen, lautet die ehrliche Frage nie „bricht das Binding” — sondern „welchen dieser generierten Namen schlägt die Laufzeit über seine Zeichenkette nach, und welchen hat der Generator bereits als direkte Referenz verdrahtet?”. Die erste Menge muss behalten werden. Die zweite benennt sich ohne Wirkung um. Treffen Sie diese Unterscheidung richtig, obfuskieren Sie eine MVVM-Toolkit-App so hart wie jede andere; treffen Sie sie falsch, geben Sie entweder die gesamte View-Model-Oberfläche preis oder liefern tote Steuerelemente aus. Die Unterscheidung ist im generierten IL sichtbar, also lesen wir es.

Was der Generator erzeugt

Beginnen wir mit einem kleinen View-Model im MVVM-Toolkit-Stil.

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;
}

Der Generator gibt eine partielle Klasse aus, die dies vervollständigt. Auf das Wesentliche gekürzt, sieht die generierte Eigenschaft so aus:

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
}

(Der echte Generator leitet die Änderungsbenachrichtigungen aus Allokationsgründen über zwischengespeicherte PropertyChangedEventArgs-Instanzen, aber der Zeichenketteninhalt ist genau der, den Sie sehen.) In diesem IL leben nun zwei Arten von Namen, und sie verhalten sich bei der Umbenennung völlig unterschiedlich.

Zeichenketten gegenüber Tokens

Getter und Setter erreichen das Backing-Feld mit ldfld/stfld gegen ein Feld-Token:

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

Dieses Token verweist auf die FieldDef-Zeile, nicht auf den Text _firstName. Benennen Sie das Feld in a um, und Nebula schreibt die Zeile um; das ldfld löst weiterhin auf. Der Feldname ist frei.

Die Benachrichtigung dagegen trägt eine echte Zeichenkettenkonstante:

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

Dieses ldstr "FirstName" ist der Name, den die Binding-Engine von WPF abzugleichen versucht. Wenn XAML {Binding FirstName} sagt, durchläuft die Engine die Eigenschaften des DataContext-Typs per Name über PropertyDescriptor/Reflection, findet eine Eigenschaft, die wörtlich FirstName heißt, abonniert PropertyChanged und filtert Benachrichtigungen durch Vergleich der PropertyName-Zeichenkette des Ereignisses. Benennen Sie die Eigenschaft in a um, und drei Dinge gehen auf einmal schief: Die Pfadsuche findet nichts, das Binding meldet einen Pfadfehler und fällt auf einen Standardwert zurück, und die Zeichenkette OnPropertyChanged("FirstName") benennt nichts mehr, worauf die Oberfläche lauscht. Alles lautlos.

Beim Command ist es dieselbe Geschichte mit einem zusätzlichen Haken. SaveCommand ist eine öffentliche Eigenschaft, also löst {Binding SaveCommand} sie per Zeichenkette genauso auf wie FirstName — behalten. Aber das Prädikat CanSave darin ist ein Delegat, übergeben als new RelayCommand(Save, CanSave). Der Generator hat nameof(CanSave) zur Kompilierzeit aufgelöst und eine direkte Methodenreferenz ausgegeben; zur Laufzeit gibt es nirgends eine Zeichenkette "CanSave". CanSave benennt sich problemlos um, ebenso Save. Der einzige Command-bezogene Name, der zur Binding-Schicht zeigt, ist SaveCommand selbst.

Per ZEICHENKETTE aufgelöst — behaltenFirstNamegenerierte Eigenschaft — {Binding FirstName}DisplayNameNotifyPropertyChangedFor → ldstr "DisplayName"SaveCommandgeneriertes Command — {Binding SaveCommand}die Binding-Engine gleicht sie per Name abper Reflection — Umbenennen ändert den VertragPer TOKEN / Delegat verdrahtet — frei_firstNameBacking-Feld — ldfld per TokenCanSaveCanExecute-Delegat — direkte ReferenzSaveCommand-Ziel — per Delegat aufgerufenOnFirstNameChangedpartielle Hooks — aufgerufen, nicht benannt

Die keep-Liste schreibt sich also von selbst: die generierten öffentlichen Eigenschaften und Commands auf jedem View-Model, dazu jede Eigenschaft, die in einem [NotifyPropertyChangedFor] benannt ist (dessen nameof zur Laufzeit zu einem ldstr wird). Alles andere, was der Generator erzeugt hat — Backing-Felder, CanExecute-Prädikate, Command-Zielmethoden, die partiellen OnXxxChanged/OnXxxChanging-Hooks — wird per Token oder Delegat referenziert und benennt sich ohne Wirkung auf das Binding um.

Nebula eingrenzen

Da die generierten Member, die Sie behalten müssen, genau die öffentliche Oberfläche Ihrer View-Models sind, drückt eine einzige, auf Member eingegrenzte keep-Regel dies präzise aus.

{
  "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" }
    ]
  }
}

Die erste Regel behält die öffentlichen Eigenschafts- und Command-Namen auf jedem View-Model — die generierten FirstName, DisplayName und SaveCommand — und der Qualifizierer members: "public" lässt das private Feld _firstName, das Prädikat CanSave, die Methode Save und die partiellen Hooks normal umbenennen. Die zweite Regel benennt alles andere im Assembly um: Ihre Dienste, Ihre Persistenzschicht, Ihre Domänenlogik. Entscheidend: Ein keep betrifft nur den Namen — die behaltenen View-Models erhalten ihre Methodenrümpfe weiterhin per Control-Flow obfuskiert und ihre String-Literale verschlüsselt. Sie verzichten auf das Umbenennen einer Handvoll bindingseitiger Namen, nicht auf den Schutz des Codes dahinter.

Wenn Sie nicht darüber nachdenken möchten, welcher Namespace die View-Models enthält, behält preservePublicApi: true die gesamte von außen sichtbare Oberfläche und erreicht dasselbe für jedes öffentliche View-Model — auf Kosten dessen, dass auch die Namen jedes anderen öffentlichen Typs behalten werden. Für eine ausgelieferte Desktop-App ohne Bibliothekskonsumenten gibt die namespacebegrenzte Regel oben weniger preis.

Vorbehalte und wann es bricht

Der Fehlermodus ist der lautlose. Eine umbenannte gebundene Eigenschaft wirft keine Ausnahme — WPF und WinUI protokollieren einen BindingExpression path error in der Debug-Trace und belassen das Steuerelement auf seinem Fallback-Wert. Ein Smoke-Test, der die App nur startet und ein Fenster sieht, besteht, während die Hälfte der Felder leer ist. Der einzige ehrliche Abnahmetest ist, den geschützten Build auszuführen und die gebundenen Bildschirme durchzugehen und dabei in der Debug-Ausgabe auf einen Pfadfehler zu achten, der den umbenannten Member nennt.

Zwei Grenzfälle sind erwähnenswert. Erstens: Ist ein View-Model internal statt öffentlich — manche Teams halten sie intern und legen sie nur über eine Schnittstelle offen —, dann deckt members: "public" es nicht ab und preservePublicApi auch nicht; die generierten Eigenschaften sind weiterhin öffentliche Member eines nicht öffentlichen Typs, und Sie müssen dieses View-Model ausdrücklich behalten. Zweitens erzeugt [ObservableProperty] auf einem Feld, dessen Name über [NotifyPropertyChangedFor] eine berechnete Eigenschaft speist, eine Abhängigkeit, die Sie übersehen können: Die berechnete Eigenschaft DisplayName muss ebenfalls behalten werden, denn ihr Name reist im Setter als Laufzeit-Zeichenkette und die Oberfläche bindet an sie. Alle öffentlichen Member des View-Models zu behalten, wie oben, deckt beide ab, ohne dass Sie sie aufzählen müssen.

Und die Grundregel unter alldem: Hier geht es darum, das geistige Eigentum Ihrer eigenen Anwendung zu schützen. Behalten Sie die Namen, die die Binding-Schicht per Zeichenkette auflöst, und obfuskieren Sie die Logik, vor der diese Bindings sitzen.

Fazit

Der MVVM-Toolkit-Generator gibt zwei Arten von Namen in Ihr Assembly aus, und die Umbenennung behandelt sie gegensätzlich. Die Namen, die zur Binding-Schicht zeigen — die generierten öffentlichen Eigenschaften, die Commands und jede über [NotifyPropertyChangedFor] ausgelöste Eigenschaft —, leben zur Laufzeit als Zeichenketten und müssen überleben. Die als Metadaten-Tokens oder direkte Delegaten verdrahteten Namen — Backing-Felder, CanExecute-Prädikate, Command-Ziele, partielle Hooks — benennen sich problemlos um. Ein keep mit members: "public" auf dem Namespace Ihrer View-Models zieht genau diese Linie, und darum ist das Obfuskieren einer CommunityToolkit.Mvvm-App ein Eingrenzungsproblem, kein Grund, die Obfuskierung zu meiden. Nebula.NET behält den Binding-Vertrag und obfuskiert alles dahinter; öffnen Sie das Ergebnis in Glass.NET, um zu bestätigen, dass die öffentlichen Namen Ihrer View-Models überlebt haben, während sich die internen als a, b, c lesen.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.