Le renommage traverse vos arbres d'expression
Une lambda comme c => c.Name ne se compile pas en corps de méthode lorsque son type est Expression<T> : elle se compile en appels de fabrique qui encodent l'accès à la propriété comme un jeton de métadonnées, pas comme une chaîne. Le renommage réécrit ce jeton avec le membre, si bien que l'arbre se résout toujours et que la lambda compilée s'exécute toujours. Le piège, c'est Member.Name : il renvoie le nom de métadonnées courant, de sorte que toute bibliothèque qui dérive une colonne, une clé JSON ou un message de validation à partir de x => x.Prop se met silencieusement à émettre le nom obfusqué. Voici l'IL exact, pourquoi le renommage atteint l'intérieur de l'arbre, et comment garder stable un contrat dérivé du nom.
Vous avez renommé chaque type et chaque membre, livré la build protégée, et votre couche de données a continué de tourner : les requêtes se sont exécutées, les lignes sont revenues. Puis une colonne nommée a est apparue en silence. La lambda que vous passez à votre ORM, o => o.Total, compilait toujours et s’exécutait toujours ; le renommage ne l’a pas cassée. Il a fait quelque chose de plus subtil : il a atteint l’intérieur de l’arbre d’expression et changé le nom que l’ORM relit dans celui-ci.
C’est la partie du renommage que l’on manque. Une lambda d’arbre d’expression n’est pas du code comme l’est un délégué : c’est une petite structure de données que votre programme construit à l’exécution, et le renommage réécrit les références qu’elle contient comme les références partout ailleurs. C’est précisément pourquoi l’arbre continue de se résoudre. Et c’est aussi précisément pourquoi tout ce qui extrait un nom de l’arbre obtient le nouveau.
La vraie question
En quoi o => o.Total se compile-t-il réellement lorsque son type est Expression<Func<Order, decimal>>, et quelles parties le renommage touche-t-il ? Répondez à cela et la colonne nommée a cesse d’être un mystère.
Ce en quoi la lambda se compile
Prenons le cas le plus simple possible :
using System;
using System.Linq.Expressions;
public class Customer { public string Name { get; set; } = ""; }
public static class P
{
public static Expression<Func<Customer, string>> E() => c => c.Name;
}
Affectée à un délégué, c => c.Name serait un corps de méthode qui lit la propriété. Affectée à Expression<Func<...>>, le compilateur émet quelque chose de complètement différent : une recette qui appelle les méthodes de fabrique d’Expression pour construire l’arbre. Voici l’IL réel de E :
.locals init ([0] class ...ParameterExpression)
IL_0000: ldtoken Customer
IL_0005: call class Type Type::GetTypeFromHandle(valuetype RuntimeTypeHandle)
IL_000a: ldstr "c"
IL_000f: call class ParameterExpression Expression::Parameter(class Type, string)
IL_0014: stloc.0
IL_0015: ldloc.0
IL_0016: ldtoken method instance string Customer::get_Name()
IL_001b: call class MethodBase MethodBase::GetMethodFromHandle(valuetype RuntimeMethodHandle)
IL_0020: castclass [System.Runtime]System.Reflection.MethodInfo
IL_0025: call class MemberExpression Expression::Property(class Expression, class MethodInfo)
IL_002a: ldc.i4.1
IL_002b: newarr ParameterExpression
IL_0030: dup
IL_0031: ldc.i4.0
IL_0032: ldloc.0
IL_0033: stelem.ref
IL_0034: call class Expression`1<...> Expression::Lambda<...>(class Expression, ParameterExpression[])
IL_0039: ret
Deux lignes décident de tout quant au comportement du renommage ici, et elles sont différentes par nature.
L’accès au membre est un jeton. IL_0016: ldtoken method instance string Customer::get_Name() charge un jeton de métadonnées de l’accesseur de la propriété, que GetMethodFromHandle résout en MethodInfo, que Expression.Property transforme en MemberExpression. L’accesseur est référencé comme l’est toute référence de méthode dans l’assembly : par un handle de métadonnées, pas par son orthographe.
Le nom du paramètre est une chaîne. IL_000a: ldstr "c" pousse le littéral "c" dans Expression.Parameter. Cette chaîne est le nom d’affichage du paramètre de la lambda. Ce sont des données brutes dans le tas #US, sans lien avec quoi que ce soit.
Member.Name lit désormais le nom renommé.Pourquoi le renommage atteint le membre mais pas le comportement de la lambda
Le renommage réécrit des références. Le ldtoken Customer::get_Name() est une référence, donc lorsque le renommeur transforme Name en a — renommant la propriété et son accesseur get_Name en get_a — il réécrit ce jeton pour qu’il pointe vers get_a. L’arbre d’expression, reconstruit à l’exécution, contient maintenant un MemberExpression dont le membre est la propriété renommée. Compilez l’arbre et invoquez-le : il lit le bon champ de stockage. Rien de l’exécution ne casse, car l’arbre n’a jamais dépendu du texte "Name" pour trouver le membre — il tenait un handle.
Le ldstr "c" n’est pas une référence, donc le renommeur le laisse tranquille, ce qui est inoffensif : le nom d’affichage du paramètre est cosmétique.
Alors d’où vient "a" ? De Member.Name. MemberExpression.Member est un MemberInfo, et MemberInfo.Name renvoie le nom de métadonnées courant du membre — après renommage, "a". Tout code qui parcourt l’arbre pour en extraire un nom lit le nom renommé :
// Un assistant typique de « dériver le nom depuis la lambda » — le motif que
// les ORM, les validateurs et les mappeurs utilisent en interne :
static string MemberName<T, TP>(Expression<Func<T, TP>> e) =>
((MemberExpression)e.Body).Member.Name; // était "Total", maintenant "a"
modelBuilder.Entity<Order>()
.Property(o => o.Total)
.HasColumnName(MemberName<Order, decimal>(o => o.Total)); // colonne "a"
La lambda a compilé. La lambda s’est exécutée. La chaîne extraite d’elle a changé — et cette chaîne était le nom de votre colonne, votre clé JSON ou le nom du champ dans un message de validation.
Contraste : la forme délégué n’a rien à casser
Affectez la même lambda à un délégué et le compilateur émet un corps de méthode ordinaire :
ldarg.0
callvirt instance string Customer::get_Name()
ret
Le renommage réécrit la cible du callvirt en get_a ; la méthode s’exécute bien ; aucun nom n’est dérivé de quoi que ce soit. Le risque est spécifique à la forme arbre d’expression, car seule cette forme transforme l’accès au membre en données qu’une bibliothèque peut inspecter pour obtenir son nom.
Comment garder le contrat stable
Deux solutions, et la seconde est à préférer.
Excluez du renommage les membres mappés. Si les noms de propriétés d’un type sont la source de vérité d’un contrat externe, gardez ces noms stables dans Nebula.NET et laissez tout le reste être renommé :
{
"inputs": ["bin/Release/net8.0/Orders.dll"],
"outputDirectory": "bin/Release/net8.0/obf",
"renameIdentifiers": true,
"encryptStrings": true,
"excludeMembers": ["Order.Total", "Order.CustomerName", "Order.PlacedAt"]
}
Maintenant o => o.Total donne Member.Name == "Total" après protection, et le nom de colonne dérivé est correct. Le coût est que ces noms de propriétés restent lisibles — acceptable pour une poignée de champs de persistance — et le reste du type est toujours renommé.
Figez le contrat pour qu’il ne dépende plus du nom. La solution plus profonde est de cesser complètement de dériver la chaîne externe du nom du membre. Donnez au mappage un nom explicite — [Column("Total")], .HasColumnName("Total"), [JsonPropertyName("total")] — et le contrat est figé quel que soit le nom du membre. Vous pouvez alors renommer la propriété librement, car rien ne lit son nom pour construire le contrat :
modelBuilder.Entity<Order>()
.Property(o => o.Total)
.HasColumnName("Total"); // figé — survit au renommage, le membre peut devenir "a"
C’est une protection strictement meilleure : le nom de la propriété n’est plus critique, vous pouvez donc l’obfusquer.
Mises en garde
- Le nom du paramètre fuit comme littéral.
ldstr "c"est cosmétique, mais un nom de paramètre descriptif (customerOrder) se trouve dans le tas#USen clair. ActivezencryptStringssi cela compte, même s’il révèle peu. - Les arbres compilés puis invoqués vont toujours bien. Si vous faites seulement
.Compile()et appelez la lambda, le renommage est transparent — ignorez tout ceci. Le risque relève exclusivement de la dérivation de noms. - Les exclusions doivent être cohérentes dans tout le graphe. Si la lambda vit dans un assembly et l’entité dans un autre, les deux doivent être protégés ensemble pour que la réécriture du jeton reste cohérente ; une entrée de keep-list doit nommer le membre dans l’assembly qui le définit réellement.
- Le chiffrement de chaînes n’aide pas ici. Le nom est un
MemberInforésolu, pas un littéral — le chiffrement n’y touche jamais. Utilisez les exclusions ou un mappage explicite.
À retenir
Le renommage n’est pas aveugle aux arbres d’expression ; il les traverse, réécrivant les jetons des membres qu’ils contiennent de sorte que l’arbre se résout toujours et que la lambda s’exécute toujours. Ce qui bouge, c’est tout nom que vous relisez dans l’arbre : Member.Name renvoie le nom courant, renommé, de sorte que les ORM, sérialiseurs et validateurs qui dérivent une chaîne de x => x.Prop se mettent silencieusement à émettre le nom obfusqué. Excluez les quelques membres dont les noms sont un contrat ou — mieux — figez le contrat avec un attribut ou un mappage explicite pour que le nom du membre ne porte aucun poids et que vous puissiez l’obfusquer comme tout le reste.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.