Cómo el renombrado rompe los bindings de MVVM Toolkit
CommunityToolkit.Mvvm convierte un campo con [ObservableProperty] en una propiedad pública y un método con [RelayCommand] en un comando, y XAML enlaza a esos nombres generados por cadena. Este artículo lee el IL generado para mostrar qué nombres resuelve un binding como cadena —y hay que conservar— frente a los que el generador cableó como delegado o token directo, que se renombran sin problema. Luego acota Nebula para conservar los primeros y ofuscar todo lo demás.
Un view-model de CommunityToolkit.Mvvm es en su mayor parte código que nunca escribiste. Declaras un campo y un atributo; un generador de código fuente produce la propiedad pública, la fontanería de PropertyChanged y el objeto de comando en tiempo de compilación. Ese es el atractivo, y también la razón por la que ofuscar una aplicación así hace tropezar a la gente. Los nombres a los que XAML enlaza no están en tu código fuente. Están generados, son públicos y algunos se resuelven por cadena en tiempo de ejecución mientras que otros solo lo parecen.
La verdadera pregunta
Cuando renombras un ensamblado, la pregunta honesta nunca es “¿se romperá el binding?”, sino “¿cuál de estos nombres generados busca el runtime por su cadena y cuál ya cableó el generador como referencia directa?”. El primer grupo hay que conservarlo. El segundo se renombra sin efecto. Acierta en esa distinción y ofuscarás una aplicación con MVVM Toolkit tan a fondo como cualquier otra; fállala y o bien filtras toda la superficie del view-model o bien entregas controles inertes. La distinción es visible en el IL generado, así que vamos a leerlo.
Qué produce el generador
Empieza con un view-model pequeño escrito al estilo 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;
}
El generador emite una clase parcial que la completa. Recortada a lo que importa, la propiedad generada tiene este aspecto:
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
}
(El generador real encamina las notificaciones de cambio a través de instancias PropertyChangedEventArgs en caché por motivos de asignación de memoria, pero el contenido de la cadena es exactamente el que ves.) Ahora viven en este IL dos tipos de nombre, y se comportan de forma completamente distinta ante el renombrado.
Cadenas frente a tokens
El getter y el setter llegan al campo de respaldo con ldfld/stfld contra un token de campo:
IL_0001: ldarg.0
IL_0002: ldfld string MyApp.CustomerViewModel::_firstName
Ese token apunta a la fila FieldDef, no al texto _firstName. Renombra el campo a a y Nebula reescribe la fila; el ldfld sigue resolviéndose. El nombre del campo es libre.
La notificación, en cambio, lleva una constante de cadena genuina:
IL_0014: ldarg.0
IL_0015: ldstr "FirstName"
IL_001a: call instance void ...ObservableObject::OnPropertyChanged(string)
Ese ldstr "FirstName" es el nombre que el motor de binding de WPF intentará emparejar. Cuando XAML dice {Binding FirstName}, el motor recorre las propiedades del tipo del DataContext por nombre mediante PropertyDescriptor/reflexión, encuentra una propiedad llamada literalmente FirstName, se suscribe a PropertyChanged y filtra las notificaciones comparando la cadena PropertyName del evento. Renombra la propiedad a a y tres cosas salen mal a la vez: la búsqueda de ruta no encuentra nada, el binding informa de un error de ruta y recae en un valor predeterminado, y la cadena OnPropertyChanged("FirstName") ya no nombra nada que la interfaz esté escuchando. Todo en silencio.
El comando es la misma historia con un matiz extra. SaveCommand es una propiedad pública, así que {Binding SaveCommand} la resuelve por cadena exactamente igual que FirstName: consérvala. Pero el predicado CanSave dentro de ella es un delegado, pasado como new RelayCommand(Save, CanSave). El generador resolvió nameof(CanSave) en tiempo de compilación y emitió una referencia directa al método; no hay ninguna cadena "CanSave" en ningún sitio en tiempo de ejecución. CanSave se renombra sin problema, y Save también. El único nombre relacionado con el comando que mira hacia la capa de binding es el propio SaveCommand.
Así que la keep-list se escribe sola: las propiedades públicas y los comandos generados en cada view-model, más cualquier propiedad nombrada dentro de un [NotifyPropertyChangedFor] (su nameof se convierte en un ldstr en tiempo de ejecución). Todo lo demás que produjo el generador —campos de respaldo, predicados CanExecute, métodos destino de comando, los hooks parciales OnXxxChanged/OnXxxChanging— se referencia por token o por delegado y se renombra sin efecto sobre el binding.
Acotar Nebula
Como los miembros generados que hay que conservar son exactamente la superficie pública de tus view-models, una única regla keep acotada a miembros lo expresa con precisión.
{
"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 primera regla conserva los nombres de propiedad y de comando públicos en cada view-model —los generados FirstName, DisplayName y SaveCommand— y el calificador members: "public" deja que el campo privado _firstName, el predicado CanSave, el método Save y los hooks parciales se renombren con normalidad. La segunda regla renombra todo lo demás del ensamblado: tus servicios, tu capa de persistencia, tu lógica de dominio. Y lo esencial: un keep es solo de nombre: los view-models conservados siguen teniendo sus cuerpos de método ofuscados con control de flujo y sus literales de cadena cifrados. Renuncias al renombrado en un puñado de nombres que miran hacia el binding, no a la protección del código que hay detrás.
Si prefieres no razonar sobre qué namespace contiene los view-models, preservePublicApi: true conserva toda la superficie visible externamente y logra lo mismo para cualquier view-model que sea público, a costa de conservar también los nombres de todos los demás tipos públicos. Para una aplicación de escritorio entregada sin consumidores de biblioteca, la regla acotada por namespace de arriba filtra menos.
Advertencias y cuándo se rompe
El modo de fallo es el silencioso. Una propiedad enlazada renombrada no lanza una excepción: WPF y WinUI registran un BindingExpression path error en la traza de depuración y dejan el control en su valor de reserva. Una prueba de humo que solo lance la aplicación y vea una ventana pasará mientras la mitad de los campos están en blanco. La única prueba de aceptación honesta es ejecutar la compilación protegida y recorrer las pantallas con bindings, vigilando en la salida de depuración un error de ruta que nombre el miembro que se renombró.
Vale la pena señalar dos casos límite. Primero, si un view-model es internal en lugar de público —algunos equipos los mantienen internos y los exponen solo a través de una interfaz—, entonces members: "public" no lo cubre y preservePublicApi tampoco; las propiedades generadas siguen siendo miembros públicos de un tipo no público, y debes conservar ese view-model de forma explícita. Segundo, [ObservableProperty] aplicado a un campo cuyo nombre alimenta una propiedad calculada vía [NotifyPropertyChangedFor] crea una dependencia que puedes pasar por alto: la propiedad calculada DisplayName también debe conservarse, porque su nombre viaja como cadena en tiempo de ejecución en el setter y la interfaz se enlaza a ella. Conservar todos los miembros públicos del view-model, como arriba, cubre ambos sin que tengas que enumerarlos.
Y la regla de base bajo todo ello: esto trata de proteger la propiedad intelectual de tu propia aplicación. Conserva los nombres que la capa de binding resuelve por cadena y ofusca la lógica que esos bindings tienen delante.
Conclusión
El generador de MVVM Toolkit emite dos tipos de nombre en tu ensamblado, y el renombrado los trata de forma opuesta. Los nombres que miran hacia la capa de binding —las propiedades públicas generadas, los comandos y cualquier propiedad lanzada a través de [NotifyPropertyChangedFor]— viven como cadenas en tiempo de ejecución y deben sobrevivir. Los nombres cableados como tokens de metadatos o delegados directos —campos de respaldo, predicados CanExecute, destinos de comando, hooks parciales— se renombran sin problema. Un keep members: "public" sobre el namespace de tus view-models traza exactamente esa línea, y por eso ofuscar una aplicación con CommunityToolkit.Mvvm es un problema de alcance, no un motivo para evitar la ofuscación. Nebula.NET conserva el contrato de binding y ofusca todo lo que hay detrás; abre el resultado en Glass.NET para confirmar que los nombres públicos de tus view-models sobrevivieron mientras las interioridades se leen como a, b, c.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.