Mantén legibles las vistas del depurador tras renombrar
Una cadena de formato [DebuggerDisplay] es un literal de tiempo de compilación que sobrevive intacto a la ofuscación — y aun así la ventana de inspección muestra {CustomerName} #{Id} o un error tras renombrar. Este artículo explica por qué: la cadena no es texto que el depurador imprime, es una pequeña expresión que su evaluador enlaza por nombre de miembro en el punto de interrupción, de modo que renombrar los miembros que nombra hace que la búsqueda falle. Luego acota Nebula.NET para que tus propias compilaciones de staging sigan siendo legibles en el depurador sin dejar esos nombres en el binario distribuido.
Adjuntas el depurador a tu propia compilación de staging para rastrear un fallo. Pasas el cursor sobre un Invoice, y la ventana de inspección — que en la última versión mostraba Acme #4821 — ahora muestra el texto literal {CustomerName} #{Id}, o un error CS1061: 'a' does not contain a definition for 'CustomerName' en rojo. El objeto está intacto. Cada campo tiene el valor correcto. La ofuscación hizo exactamente lo que le pediste. El depurador simplemente perdió lo único que le indicaste que mostrara.
La verdadera pregunta
Una cadena de formato [DebuggerDisplay] es un literal de cadena de tiempo de compilación. Renombrar no toca los literales de cadena — esa es toda la razón por la que el ToString() de un record o una plantilla de mensaje de Serilog sobreviven a la ofuscación. Entonces, si la cadena de formato está intacta, ¿por qué la vista está rota? Porque la cadena no es texto que el depurador imprime. Es un pequeño programa que el depurador ejecuta en el punto de interrupción, y ese programa busca miembros por nombre — que es precisamente lo que renombrar reescribe.
La cadena de formato es un literal — y ahí está la trampa
Toma un tipo anotado corriente.
[DebuggerDisplay("{CustomerName} #{Id}")]
public sealed class Invoice
{
public string CustomerName { get; init; }
public int Id { get; init; }
public decimal Total { get; init; }
}
El atributo se almacena en los metadatos como una fila de atributo personalizado sobre Invoice, y el argumento del constructor — tu cadena de formato — vive como bytes UTF-8 con prefijo de longitud en el montículo #Blob:
.custom instance void [System.Private.CoreLib]
System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = (
01 00 14 7B 43 75 73 74 6F 6D 65 72 4E 61 6D 65 // ...{CustomerName
7D 20 23 7B 49 64 7D 00 00 ) // } #{Id}..
)
Esos bytes 7B 43 75 73 74… deletrean {CustomerName. Son un argumento de constructor opaco, no un nombre de metadatos — el ofuscador no tiene motivo (ni forma segura) de meterse dentro de un blob de atributo arbitrario y reescribir una subcadena ahí. Así que cuando Nebula renombra la fila de propiedad CustomerName a b, la cadena de formato sigue diciendo CustomerName. El literal sobrevive perfectamente. Ese es el problema, no la cura.
Qué hace el depurador con ella
En un punto de interrupción, el evaluador de expresiones de Visual Studio lee el atributo DebuggerDisplay, divide el formato por sus segmentos {…} y compila cada segmento como una expresión evaluada contra la instancia — this.CustomerName y this.Id. Enlaza esos identificadores contra los metadatos del ensamblado que realmente está cargado en el proceso: el renombrado. Ya no hay ningún miembro llamado CustomerName en el tipo cargado; se llama b. El enlace falla, y el evaluador reporta un error para ese segmento o recurre a mostrar las llaves en bruto. El valor "Acme" está justo ahí, en el campo b — al depurador simplemente no se le dijo que mirara ahí.
Esta es la misma división que gobierna el destructuring de Serilog y el enlace de configuración: un valor que es un literal de tiempo de compilación sobrevive al renombrado, pero un nombre resuelto en tiempo de ejecución lo sigue. DebuggerDisplay es inusual solo en que la resolución ocurre en tiempo de depuración, y agrupa ambas mitades en un atributo — un literal que sobrevive y que nombra miembros que el renombrador ha movido.
Contrástalo con el caso sin atributo. Quita [DebuggerDisplay] por completo y el depurador recurre al ToString() del tipo. Para un record, ToString() es generado por el compilador con cada nombre de miembro incrustado como literal, así que imprime los mismos nombres antes y después de renombrar. Un tipo sin atributo se muestra bien; añadir un DebuggerDisplay que nombra miembros es lo que introduce la dependencia por nombre en tiempo de depuración.
Acotar Nebula para que tus propias compilaciones sigan legibles
La clave es para quién son estos atributos. DebuggerDisplay, DebuggerTypeProxy y DebuggerBrowsable existen para una persona que adjunta un depurador — y en la compilación que entregas a los clientes, nadie lo hace. Una versión endurecida con anti-depuración y una ruta crítica virtualizada se construye para que adjuntar un depurador se detecte y el paso a paso no tenga sentido; una vista de inspección rota en esa compilación no te cuesta nada, porque nunca la abres. Así que la primera y mejor respuesta es: no intentes preservar la vista en la compilación del cliente. Deja que se renombre.
Donde la vista debe sobrevivir es en las compilaciones que realmente depuras — local, y una de staging que refleje producción. Si esa compilación de staging está ligeramente ofuscada o nada, ya está; los nombres están intactos. Si está totalmente renombrada y aun así necesitas adjuntar, conserva solo lo que la vista lee — y conserva la hoja, no el tipo. La forma más barata es encaminar toda la vista a través de un miembro y conservar ese único nombre:
[DebuggerDisplay("{DebugView,nq}")]
public sealed class Invoice
{
public string CustomerName { get; init; }
public int Id { get; init; }
public decimal Total { get; init; }
[Obfuscation(Feature = "renaming", Exclude = true)] // the only name the debugger binds
private string DebugView => $"{CustomerName} #{Id}";
}
Ahora el evaluador enlaza exactamente un nombre — DebugView — que el atributo conserva. Dentro de esa propiedad, CustomerName, Id y Total son accesos de miembro ordinarios compilados a IL; renombrar los reescribe de forma coherente junto con todas las demás referencias, así que siguen renombrándose a b, c, d en todas partes y no filtran nada en un descompilador. Cambiaste tres nombres de propiedad conservados por un nombre de indirección conservado, y el especificador ,nq quita las comillas para que la vista se lea limpia.
Si prefieres una regla de configuración en lugar de un atributo — digamos un espacio de nombres de diagnóstico entero de vistas de depuración — conserva los miembros hoja ahí y renombra todo lo demás:
{
"schemaVersion": 1,
"inputs": [ "bin/Release/net8.0/Billing.dll" ],
"outputDirectory": "protected",
"encryptStrings": true,
"controlFlowObfuscation": true,
"renaming": {
"rules": [
{ "pattern": "Billing.Diagnostics.DebugViews.*", "action": "keep", "members": "public" },
{ "pattern": "Billing.*", "action": "rename" }
]
}
}
nebula protect --config nebula.config.json
Un nombre conservado sigue siendo un cuerpo totalmente protegido — el miembro DebugView conservado mantiene su ofuscación de flujo de control y su cifrado de cadenas; solo su nombre permanece legible. Esa es la disciplina estándar de la keep-list: conserva el conjunto mínimo de nombres que algo resuelve como cadena, aquí en tiempo de depuración.
Cuándo se rompe
Vale la pena conocer tres casos límite. Primero, DebuggerTypeProxy: su argumento typeof(InvoiceDebugView) es una referencia de tipo que Nebula reescribe de forma coherente, así que el proxy sigue adjuntándose tras renombrar — pero los nombres de propiedad públicos de la propia clase proxy son lo que el depurador expande en el árbol de inspección, y esos se renombran a a, b, c. Si quieres esa vista expandida legible, conserva los nombres de miembro públicos del tipo proxy; de lo contrario es solo más ruido en una ventana que puedes dejar renombrar.
Segundo, el cifrado de cadenas no cubre la cadena de formato. encryptStrings reescribe las cargas ldstr en los cuerpos de método; el argumento de DebuggerDisplay es un valor de constructor en un blob de atributo, no un cuerpo de método, así que permanece en texto plano incluso en la compilación endurecida. Los nombres de miembro que menciona quedan ahí al descubierto — una pequeña fuga, y otra razón para preferir la única indirección DebugView (que no nombra nada) o simplemente no llevar el atributo a la compilación distribuida.
Tercero, los atributos de paso a paso son irrelevantes, no están rotos. [DebuggerStepThrough] y [DebuggerHidden] afectan solo al paso a paso, que renombrar deja intacto — pero una vez que un método tiene el flujo de control aplanado o está virtualizado, no queda IL ordinario que recorrer paso a paso, así que esos atributos no tienen sobre qué actuar. No añadas reglas de conservación para ellos; no hay nada que conservar.
Conclusión
Un [DebuggerDisplay] es un literal que nombra miembros, y renombrar mueve los miembros de debajo del literal. La cadena de formato sobrevive intacta; el evaluador del depurador enlaza los nombres que contiene contra los metadatos renombrados y falla. Decide dónde la vista realmente necesita funcionar — tus compilaciones depurables, no la endurecida del cliente — y en esas, encamínala a través de un único miembro que conserves en lugar de nombrar varias propiedades que luego tengas que dejar legibles. Protege el resto con Nebula.NET, y luego abre el resultado en Glass.NET para confirmar que tus tipos se leen como a, b, c mientras el único DebugView del que dependen tus ingenieros sigue deletreando su nombre.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.