Pourquoi le renommage casse un modèle compilé EF Core
Un modèle compilé EF Core intègre les noms de propriétés et de champs de stockage de vos entités sous forme de littéraux de chaîne et effectue une réflexion dessus au démarrage : renommer les entités transforme donc GetProperty("Id") en null et fait planter la première requête. Voici la raison exacte au niveau des métadonnées, et la keep-list minimale qui corrige cela sans renoncer à la protection du reste de l'application.
Une équipe active l”obfuscation sur une application de bureau déjà publiée, la compilation est propre, et l”application meurt à la première requête base de données avec une InvalidOperationException au plus profond du générateur de modèle d”EF Core — une pile d”appels pleine de RuntimeModel, AddProperty et pas une seule ligne de leur propre code. Ils n”avaient rien touché à EF. Ce qu”ils avaient fait, en revanche, des mois plus tôt, c”était lancer dotnet ef dbcontext optimize pour rogner le temps de démarrage avec un modèle compilé. Le renommage et les modèles compilés ne cohabitent pas par défaut, et la raison en est précise et mérite d”être comprise avant de recourir à la keep-list.
Ce qu”est réellement un modèle compilé
Un DbContext EF Core normal construit son modèle à l”exécution en effectuant une réflexion sur vos classes d”entité la première fois que le contexte est utilisé. Cette réflexion n”est pas gratuite — pour un grand modèle, ce sont des dizaines de millisecondes de pur coût de démarrage. Le modèle compilé l”élimine. dotnet ef dbcontext optimize parcourt votre modèle une fois, à la compilation, et émet du C# ordinaire qui reconstruit le même IModel directement, sans découverte de conventions. Vous le branchez d”une seule ligne :
optionsBuilder.UseModel(BlogContextModel.Instance);
Le code généré n”a rien de magique — c”est du code source ordinaire que vous pouvez ouvrir et lire. Pour chaque entité, EF écrit un *EntityType.cs avec une méthode Create, et c”est dans cette méthode que réside le problème. Voici la forme de ce qu”il émet pour une entité Blog avec un Id et 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;
}
Observez ce dont dépend cet appel à AddProperty. Le type CLR arrive via typeof(Blog) — un jeton de métadonnées. Mais la propriété est localisée avec la chaîne "Id", et le champ de stockage avec la chaîne "<Id>k__BackingField", le nom généré par le compilateur derrière une propriété automatique. Le modèle compilé est, de fait, un second contrat superposé à vos types d”entité — exprimé presque entièrement en chaînes de réflexion.
La raison, au niveau des métadonnées, pour laquelle cela casse
Renommer un assembly n”est pas un rechercher-remplacer sur du texte : cela modifie des tables de métadonnées. Quand Nebula renomme le type Blog et sa propriété Id, il réécrit la colonne Name de la ligne TypeDef et la colonne Name de la ligne Property — Id devient, disons, b. Chaque référence par jeton à ces membres est réécrite de concert, ce qui est précisément pourquoi typeof(Blog) continue de fonctionner : c”est un jeton TypeRef, et l”obfuscateur le corrige avec tout le reste.
Un littéral de chaîne n”est pas un jeton. GetProperty("Id") se compile en ldstr "Id", et ce "Id" réside dans le heap de chaînes utilisateur — le flux #US — un bloc de texte UTF-16 totalement distinct de la table Property. Le renommage ne touche jamais #US. Ainsi, après obfuscation, vous avez une ligne Property dont le nom est b et un ldstr qui dit toujours Id, et à l”exécution EF compare le second au premier et ne trouve rien.
La recherche du champ de stockage échoue de la même manière, et c”est la plus surprenante des deux : <Id>k__BackingField est un nom privé, synthétisé par le compilateur, que la plupart des développeurs ne considèrent jamais comme faisant partie d”un contrat. Le modèle compilé en a fait un.
L”échec est un plantage au démarrage, pas une mauvaise réponse
C”est la bonne nouvelle au sein d”une arête par ailleurs tranchante. Un modèle compilé renommé ne renvoie pas silencieusement de mauvaises données — il ne peut tout simplement pas construire l”IModel. On remet à AddProperty un PropertyInfo null, et EF lève une InvalidOperationException la première fois que le contexte matérialise son modèle. Vous l”apprenez au lancement de l”application, dans le premier test d”intégration qui ouvre un contexte, pas en production trois semaines plus tard. Comparé aux échecs silencieux que le renommage provoque ailleurs — un sérialiseur émettant {"b":…}, une classe d”options retombant sur ses valeurs par défaut — un plantage net dès la première ligne est un cadeau.
La solution : conservez les entités, renommez tout le reste
Le modèle compilé effectue une réflexion sur vos types d”entité par chaîne, exactement comme un sérialiseur ou un framework à forte réflexion, il appartient donc à la même catégorie mentale : les noms qu”il résout sont un contrat, et les contrats vont dans la keep-list. Dans 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" }
]
}
}
Deux points le rendent plus étroit qu”il n”y paraît. D”abord, le keep ne porte que sur le namespace des entités : votre sous-classe de DbContext, vos dépôts, services, view models et les classes du modèle compilé générées elles-mêmes sont tous sous la règle plus large rename et sont obfusqués normalement. Les classes du modèle compilé se renomment sans problème parce que votre code les référence par type (UseModel(BlogContextModel.Instance)), référence que l”obfuscateur réécrit de façon cohérente.
Ensuite, notez ce que le keep doit couvrir. Un DTO sérialisé n”a généralement besoin que de conserver ses noms de propriété publics, donc "members": "public" suffit. Un modèle compilé est plus vorace : il effectue aussi une réflexion sur les champs de stockage privés, avec leurs chaînes <Name>k__BackingField. Un keep d”entité ne peut donc pas être restreint aux membres publics — les champs de stockage doivent rester eux aussi — ce qui, en pratique, revient à conserver intégralement les noms du type d”entité. C”est le coût honnête, et il est plus faible qu”il n”en a l”air : les classes d”entité sont généralement des POCO dont les noms de propriété reflètent déjà des colonnes de base de données, leurs noms n”ont donc jamais porté de secret. Vous livrez à un décompilateur la forme de vos tables, qu”il pourrait de toute façon lire depuis la base, pendant que votre vraie logique reste renommée.
L”alternative : ne pas livrer le modèle compilé du tout
Si le budget de démarrage d”une application n”est pas serré — la plupart des processus de bureau et des serveurs de longue durée ne le sont pas — la solution la plus simple est de cesser d”utiliser un modèle compilé pour la build protégée. Supprimez l”appel à UseModel (ou protégez-le par une condition) et EF revient à construire le modèle en effectuant une réflexion sur les types d”entité à la première utilisation. La réflexion à l”exécution sur des entités renommées fonctionne bien *tant qu”*EF découvre les membres à partir des types eux-mêmes plutôt qu”à partir de chaînes codées en dur, car les mappages [Column]/[Table] et les conventions continuent d”opérer sur les métadonnées vivantes. Vous échangez quelques millisecondes de latence à la première requête contre une chose en moins dans la keep-list. Mesurez d”abord : le modèle compilé ne justifie son coût que quand le modèle est grand et que la latence de démarrage est une exigence du produit.
Mises en garde et cas où cela mord encore
La keep-list corrige le renommage, mais gardez deux choses en tête. Si vous ajoutez ou renommez plus tard une propriété d”entité dans le code source, vous devez régénérer le modèle compilé (dotnet ef dbcontext optimize) avant de compiler et d”obfusquer — un modèle compilé obsolète est un bug avec ou sans obfuscateur, mais l”obfuscation le fait ressembler à un bug d”obfuscation. Et si vos types d”entité vivent dans un assembly séparé de celui que vous obfusquez, la règle keep doit viser cet assembly ; un modèle compilé généré dans votre application principale effectue tout de même une réflexion par-delà la frontière de l”assembly, vers le projet d”entités, par chaîne.
La seule chose que vous ne pouvez pas faire, c”est laisser Nebula renommer les entités en espérant qu”il « voie à travers » les chaînes de GetProperty. L”obfuscateur n”a aucun moyen de savoir qu”un ldstr "Id" arbitraire est censé nommer un membre qu”il a renommé — ce n”est que du texte dans un heap. Ce n”est pas tant une limite de Nebula qu”une propriété du fonctionnement de la réflexion par chaîne face à des métadonnées renommées, et c”est la même raison pour laquelle tout contrat par nom en .NET a besoin d”une entrée keep.
À retenir
Un modèle compilé est une optimisation de performance qui transforme discrètement les noms de propriétés et de champs de stockage de vos entités en un contrat de réflexion cuit dans l”IL. Le renommage réécrit les métadonnées vers lesquelles ces chaînes pointent, mais jamais les chaînes, si bien que les appels GetProperty et GetField du modèle compilé renvoient null et que la construction du modèle lève une exception au démarrage. Conservez les types d”entité, laissez le DbContext et les classes du modèle généré se renommer, et vérifiez que la build protégée ouvre un contexte avant de livrer — le mécanisme est tranchant, mais il échoue bruyamment et la solution tient en deux lignes de configuration.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.