Skip to content
← Todas las publicaciones
· Delta1 Labs RenamingNebula

El renombrado atraviesa tus árboles de expresión

Una lambda como c => c.Name no se compila a un cuerpo de método cuando su tipo es Expression<T>: se compila a llamadas de fábrica que codifican el acceso a la propiedad como un token de metadatos, no como una cadena. El renombrado reescribe ese token junto con el miembro, así que el árbol sigue resolviéndose y la lambda compilada sigue ejecutándose. La trampa es Member.Name: devuelve el nombre de metadatos vigente, de modo que cualquier librería que derive una columna, una clave JSON o un mensaje de validación a partir de x => x.Prop empieza a emitir en silencio el nombre ofuscado. Aquí está el IL exacto, por qué el renombrado llega al interior del árbol y cómo mantener estable un contrato derivado del nombre.

Renombraste cada tipo y cada miembro, enviaste la compilación protegida y tu capa de datos siguió funcionando: las consultas se ejecutaron, las filas volvieron. Luego apareció en silencio una columna llamada a. La lambda que pasas a tu ORM, o => o.Total, seguía compilando y seguía ejecutándose; el renombrado no la rompió. Hizo algo más sutil: llegó al interior del árbol de expresión y cambió el nombre que el ORM vuelve a leer de él.

Esta es la parte del renombrado que la gente pasa por alto. Una lambda de árbol de expresión no es código como lo es un delegado: es una pequeña estructura de datos que tu programa construye en tiempo de ejecución, y el renombrado reescribe las referencias que contiene igual que las referencias de cualquier otro sitio. Por eso el árbol sigue resolviéndose. Y por eso también cualquier cosa que extraiga un nombre del árbol obtiene el nuevo.

La verdadera pregunta

¿A qué se compila realmente o => o.Total cuando su tipo es Expression<Func<Order, decimal>>, y qué partes toca el renombrado? Responde a eso y la columna llamada a deja de ser un misterio.

A qué se compila la lambda

Tomemos el caso más sencillo posible:

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;
}

Asignada a un delegado, c => c.Name sería un cuerpo de método que lee la propiedad. Asignada a Expression<Func<...>>, el compilador emite algo completamente distinto: una receta que llama a los métodos de fábrica de Expression para construir el árbol. Este es el IL real 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

Dos líneas deciden todo sobre cómo se comporta aquí el renombrado, y son distintas en naturaleza.

El acceso al miembro es un token. IL_0016: ldtoken method instance string Customer::get_Name() carga un token de metadatos del captador de la propiedad, que GetMethodFromHandle resuelve a un MethodInfo, que Expression.Property convierte en un MemberExpression. El captador se referencia igual que cualquier referencia a un método en el ensamblado: por un identificador de metadatos, no por su grafía.

El nombre del parámetro es una cadena. IL_000a: ldstr "c" empuja el literal "c" a Expression.Parameter. Esa cadena es el nombre visible del parámetro de la lambda. Son datos planos en el heap #US, sin vínculo con nada.

c => c.Name construido por llamadas de fábrica, no un cuerpo de métodoacceso al miembroExpression.Property(p, mi)ldtoken get_NameTOKEN de metadatos, no una cadenaparámetroExpression.Parameter(t, "c")ldstr "c"LITERAL de cadena, solo nombre visiblepasada de renombrado — reescribe referencias, deja los literalesget_Name → get_a (destino del token reescrito)"c" intacto (no es una referencia)ejecución: el árbol sigue resolviéndose — pero el NOMBRE derivado se moviólambda.Compile()(order) → lee la propiedad correcta ✓((MemberExpression)body).Member.Name → "a"→ columna "a", no "Total"
El acceso al miembro es un token de metadatos que el renombrado reescribe con el miembro; el nombre del parámetro es un literal inerte. El árbol se resuelve correctamente, pero Member.Name ahora lee el nombre renombrado.

Por qué el renombrado llega al miembro pero no al comportamiento de la lambda

El renombrado reescribe referencias. El ldtoken Customer::get_Name() es una referencia, así que cuando el renombrador convierte Name en a —renombrando la propiedad y su captador get_Name a get_a— reescribe ese token para que apunte a get_a. El árbol de expresión, reconstruido en tiempo de ejecución, ahora contiene un MemberExpression cuyo miembro es la propiedad renombrada. Compila el árbol e invócalo y lee el campo de respaldo correcto. Nada de la ejecución se rompe, porque el árbol nunca dependió del texto "Name" para encontrar el miembro: tenía un identificador.

El ldstr "c" no es una referencia, así que el renombrador lo deja en paz, lo cual es inofensivo: el nombre visible del parámetro es cosmético.

Entonces, ¿de dónde sale "a"? De Member.Name. MemberExpression.Member es un MemberInfo, y MemberInfo.Name devuelve el nombre de metadatos vigente del miembro: tras el renombrado, "a". Cualquier código que recorra el árbol para extraer un nombre lee el renombrado:

// Un ayudante típico de "derivar el nombre de la lambda" — el patrón que usan
// por dentro los ORM, los validadores y los mapeadores:
static string MemberName<T, TP>(Expression<Func<T, TP>> e) =>
    ((MemberExpression)e.Body).Member.Name;   // era "Total", ahora "a"

modelBuilder.Entity<Order>()
    .Property(o => o.Total)
    .HasColumnName(MemberName<Order, decimal>(o => o.Total)); // columna "a"

La lambda compiló. La lambda se ejecutó. La cadena extraída de ella cambió, y esa cadena era el nombre de tu columna, tu clave JSON o el nombre del campo en un mensaje de validación.

Contraste: la forma de delegado no tiene nada que romper

Asigna la misma lambda a un delegado y el compilador emite un cuerpo de método ordinario:

ldarg.0
callvirt   instance string Customer::get_Name()
ret

El renombrado reescribe el destino del callvirt a get_a; el método se ejecuta bien; no se deriva ningún nombre de nada. El riesgo es específico de la forma de árbol de expresión, porque solo esa forma convierte el acceso al miembro en datos que una librería puede inspeccionar para obtener su nombre.

Cómo mantener estable el contrato

Dos soluciones, y la segunda es la preferible.

Excluye del renombrado los miembros mapeados. Si los nombres de las propiedades de un tipo son la fuente de verdad de un contrato externo, mantén esos nombres estables en Nebula.NET y deja que todo lo demás se renombre:

{
  "inputs": ["bin/Release/net8.0/Orders.dll"],
  "outputDirectory": "bin/Release/net8.0/obf",
  "renameIdentifiers": true,
  "encryptStrings": true,
  "excludeMembers": ["Order.Total", "Order.CustomerName", "Order.PlacedAt"]
}

Ahora o => o.Total da Member.Name == "Total" tras la protección, y el nombre de columna derivado es correcto. El coste es que esos nombres de propiedad quedan legibles —aceptable para un puñado de campos de persistencia—, y el resto del tipo sigue renombrándose.

Fija el contrato para que ya no dependa del nombre. La solución más profunda es dejar de derivar la cadena externa del nombre del miembro por completo. Dale al mapeo un nombre explícito —[Column("Total")], .HasColumnName("Total"), [JsonPropertyName("total")]— y el contrato queda fijado sin importar cómo se llame el miembro. Entonces puedes renombrar la propiedad libremente, porque nada lee su nombre para construir el contrato:

modelBuilder.Entity<Order>()
    .Property(o => o.Total)
    .HasColumnName("Total");   // fijado — sobrevive al renombrado, el miembro puede volverse "a"

Esto es protección estrictamente mejor: el nombre de la propiedad ya no es crítico, así que puedes ofuscarlo.

Advertencias

  • El nombre del parámetro se filtra como literal. ldstr "c" es cosmético, pero un nombre de parámetro descriptivo (customerOrder) queda en el heap #US en texto plano. Activa encryptStrings si te importa, aunque revela poco.
  • Los árboles compilados e invocados siempre van bien. Si solo haces .Compile() e invocas la lambda, el renombrado es transparente: ignora todo esto. El riesgo es exclusivamente la derivación de nombres.
  • Las exclusiones deben ser coherentes en todo el grafo. Si la lambda vive en un ensamblado y la entidad en otro, ambos deben protegerse juntos para que la reescritura del token siga siendo coherente; una entrada de la keep-list debe nombrar el miembro en el ensamblado que realmente lo define.
  • El cifrado de cadenas no ayuda aquí. El nombre es un MemberInfo resuelto, no un literal: el cifrado nunca lo toca. Usa exclusiones o mapeo explícito.

Conclusión

El renombrado no es ciego a los árboles de expresión; los atraviesa, reescribiendo los tokens de los miembros que contienen de modo que el árbol sigue resolviéndose y la lambda sigue ejecutándose. Lo que se mueve es cualquier nombre que vuelvas a leer del árbol: Member.Name devuelve el nombre vigente, renombrado, así que los ORM, serializadores y validadores que derivan una cadena de x => x.Prop empiezan en silencio a emitir el ofuscado. Excluye los pocos miembros cuyos nombres sean un contrato o —mejor— fija el contrato con un atributo o mapeo explícito para que el nombre del miembro no cargue ningún peso y puedas ofuscarlo como todo lo demás.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.