Por qué el renombrado rompe un modelo compilado de EF Core
Un modelo compilado de EF Core incrusta los nombres de las propiedades y de los campos de respaldo de tus entidades como literales de cadena y reflexiona sobre ellos al arrancar, así que renombrar las entidades convierte GetProperty("Id") en null y bloquea la primera consulta. Esta es la razón exacta a nivel de metadatos y la keep-list mínima que lo arregla sin renunciar a la protección del resto de la aplicación.
Un equipo activa la ofuscación en una aplicación de escritorio ya publicada, la compilación sale limpia y la aplicación muere en la primera consulta a la base de datos con una InvalidOperationException en lo más profundo del generador de modelos de EF Core: un stack trace lleno de RuntimeModel, AddProperty y ni una sola línea de su propio código. No habían tocado nada de EF. Lo que sí habían hecho, meses antes, era ejecutar dotnet ef dbcontext optimize para recortar el tiempo de arranque con un modelo compilado. El renombrado y los modelos compilados no conviven por defecto, y la razón es precisa y vale la pena entenderla antes de recurrir a la keep-list.
Qué es realmente un modelo compilado
Un DbContext normal de EF Core construye su modelo en tiempo de ejecución reflexionando sobre tus clases de entidad la primera vez que se usa el contexto. Esa reflexión no es gratis: en un modelo grande son decenas de milisegundos de puro coste de arranque. El modelo compilado lo elimina. dotnet ef dbcontext optimize recorre tu modelo una vez, en tiempo de compilación, y emite C# puro que reconstruye el mismo IModel directamente, sin necesidad de descubrir convenciones. Lo conectas con una sola línea:
optionsBuilder.UseModel(BlogContextModel.Instance);
El código generado no es magia: es código fuente ordinario que puedes abrir y leer. Para cada entidad EF escribe un *EntityType.cs con un método Create, y ese método es donde está el problema. Esta es la forma de lo que emite para una entidad Blog con un Id y un Title:
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"MyApp.Data.Blog",
typeof(Blog),
baseEntityType,
propertyCount: 2);
var id = runtimeEntityType.AddProperty(
"Id",
typeof(int),
propertyInfo: typeof(Blog).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
field: typeof(Blog).GetField("<Id>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd);
// ... Title, keys, indexes ...
return runtimeEntityType;
}
Fíjate en de qué depende esa llamada a AddProperty. El tipo CLR llega a través de typeof(Blog), un token de metadatos. Pero la propiedad se localiza con la cadena "Id", y el campo de respaldo con la cadena "<Id>k__BackingField", el nombre generado por el compilador detrás de una propiedad automática. El modelo compilado es, en efecto, un segundo contrato superpuesto a tus tipos de entidad, expresado casi por completo en cadenas de reflexión.
La razón de metadatos por la que se rompe
Renombrar un ensamblado no es un buscar-y-reemplazar sobre texto: edita tablas de metadatos. Cuando Nebula renombra el tipo Blog y su propiedad Id, reescribe la columna Name de la fila TypeDef y la columna Name de la fila Property —Id se convierte, por ejemplo, en b. Cada referencia por token a esos miembros se reescribe al unísono, que es exactamente la razón por la que typeof(Blog) sigue funcionando: es un token TypeRef, y el ofuscador lo corrige junto con todo lo demás.
Un literal de cadena no es un token. GetProperty("Id") se compila a ldstr "Id", y ese "Id" vive en el heap de cadenas de usuario —el stream #US—, un bloque de texto UTF-16 completamente separado de la tabla Property. El renombrado nunca toca #US. Así que tras la ofuscación tienes una fila Property cuyo nombre es b y un ldstr que sigue diciendo Id, y en tiempo de ejecución EF compara la segunda con la primera y no encuentra nada.
La búsqueda del campo de respaldo falla del mismo modo, y es la más sorprendente de las dos: <Id>k__BackingField es un nombre privado, sintetizado por el compilador, que la mayoría de los desarrolladores nunca considera parte de un contrato. El modelo compilado lo convirtió en uno.
El fallo es un bloqueo al arrancar, no una respuesta errónea
Esta es la buena noticia dentro de una arista por lo demás afilada. Un modelo compilado renombrado no devuelve datos malos en silencio: directamente no puede construir el IModel. A AddProperty se le entrega un PropertyInfo null, y EF lanza una InvalidOperationException la primera vez que el contexto materializa su modelo. Te enteras al lanzar la aplicación, en la primera prueba de integración que abre un contexto, no en producción tres semanas después. Comparado con los fallos silenciosos que el renombrado provoca en otros lugares —un serializador emitiendo {"b":…}, una clase de opciones cayendo a sus valores por defecto—, un bloqueo rotundo en la línea uno es un regalo.
La solución: mantén las entidades, renombra todo lo demás
El modelo compilado reflexiona sobre tus tipos de entidad por cadena, exactamente igual que un serializador o un framework intensivo en reflexión, así que pertenece a la misma categoría mental: los nombres que resuelve son un contrato, y los contratos van a la keep-list. En nebula.config.json:
{
"schemaVersion": 1,
"inputs": [ "bin/Release/net8.0/MyApp.dll" ],
"outputDirectory": "protected",
"encryptStrings": true,
"controlFlowObfuscation": true,
"renaming": {
"rules": [
{ "pattern": "MyApp.Data.Entities.*", "action": "keep" },
{ "pattern": "MyApp.*", "action": "rename" }
]
}
}
Dos puntos lo hacen más estrecho de lo que parece. Primero, el keep es solo sobre el namespace de entidades: tu subclase de DbContext, tus repositorios, servicios, view models y las propias clases del modelo compilado generado están todas bajo la regla más amplia rename y se ofuscan con normalidad. Las clases del modelo compilado se renombran sin problema porque tu código las referencia por tipo (UseModel(BlogContextModel.Instance)), referencia que el ofuscador reescribe de forma coherente.
Segundo, fíjate en lo que debe cubrir el keep. Un DTO serializado normalmente solo necesita mantener sus nombres de propiedad públicos, así que "members": "public" basta. Un modelo compilado es más voraz: reflexiona también sobre los campos de respaldo privados, con sus cadenas <Name>k__BackingField. Así que un keep de entidad no puede estrecharse a los miembros públicos —los campos de respaldo también deben quedarse—, lo que en la práctica significa mantener los nombres del tipo de entidad por completo. Ese es el coste honesto, y es menor de lo que parece: las clases de entidad suelen ser POCOs cuyos nombres de propiedad ya reflejan columnas de base de datos, así que sus nombres nunca guardaban un secreto. Le estás entregando a un decompilador la forma de tus tablas, que de todos modos podría leer desde la base de datos, mientras tu lógica real permanece renombrada.
La alternativa: no distribuir el modelo compilado en absoluto
Si el presupuesto de arranque de una aplicación no es ajustado —la mayoría de los procesos de escritorio y de servidor de larga duración no lo son—, la solución más simple es dejar de usar un modelo compilado para la compilación protegida. Elimina la llamada a UseModel (o protégela con una condición) y EF vuelve a construir el modelo reflexionando sobre los tipos de entidad en el primer uso. La reflexión en tiempo de ejecución sobre entidades renombradas funciona bien siempre que EF esté descubriendo miembros a partir de los propios tipos en lugar de cadenas incrustadas, porque los mapeos [Column]/[Table] y las convenciones siguen operando sobre los metadatos vivos. Cambias unos pocos milisegundos de latencia en la primera consulta por una cosa menos en la keep-list. Mide primero: el modelo compilado solo se gana su sitio cuando el modelo es grande y la latencia de arranque es un requisito del producto.
Advertencias y cuándo sigue mordiendo
La keep-list arregla el renombrado, pero ten presentes dos cosas. Si más adelante añades o renombras una propiedad de entidad en el código fuente, debes regenerar el modelo compilado (dotnet ef dbcontext optimize) antes de compilar y ofuscar —un modelo compilado obsoleto es un error con o sin ofuscador, pero la ofuscación hace que parezca un error de ofuscación. Y si tus tipos de entidad viven en un ensamblado separado del que ofuscas, la regla keep tiene que apuntar a ese ensamblado; un modelo compilado generado en tu aplicación principal sigue reflexionando a través de la frontera del ensamblado hacia el proyecto de entidades por cadena.
Lo único que no puedes hacer es dejar que Nebula renombre las entidades y esperar que “vea a través” de las cadenas de GetProperty. El ofuscador no tiene forma de saber que un ldstr "Id" arbitrario pretende nombrar a un miembro que renombró: es solo texto en un heap. Eso no es tanto una limitación de Nebula como una propiedad de cómo funciona la reflexión basada en cadenas contra metadatos renombrados, y es la misma razón por la que todo contrato por nombre en .NET necesita una entrada keep.
Conclusión
Un modelo compilado es una optimización de rendimiento que, en silencio, convierte los nombres de las propiedades y de los campos de respaldo de tus entidades en un contrato de reflexión horneado en el IL. El renombrado reescribe los metadatos a los que apuntan esas cadenas, pero nunca las cadenas, así que las llamadas GetProperty y GetField del modelo compilado devuelven null y la construcción del modelo lanza una excepción al arrancar. Mantén los tipos de entidad, deja que el DbContext y las clases del modelo generado se renombren, y verifica que la compilación protegida abre un contexto antes de distribuir: el mecanismo es afilado, pero falla a gritos y la solución son dos líneas de configuración.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.