Skip to content
← Alle Beiträge
· Delta1 Labs RenamingNebula

Umbenennung dringt in Ihre Expression Trees ein

Ein Lambda wie c => c.Name wird nicht zu einem Methodenrumpf kompiliert, wenn sein Typ Expression<T> ist — es wird zu Fabrikaufrufen kompiliert, die den Property-Zugriff als Metadaten-Token codieren, nicht als Zeichenfolge. Die Umbenennung schreibt dieses Token zusammen mit dem Member um, der Baum löst also weiterhin auf und das kompilierte Lambda läuft weiterhin. Die Falle ist Member.Name: er liefert den aktuellen Metadaten-Namen, sodass jede Bibliothek, die aus x => x.Prop eine Spalte, einen JSON-Schlüssel oder eine Validierungsmeldung ableitet, still den obfuskierten Namen ausgibt. Hier ist das exakte IL, warum die Umbenennung ins Innere des Baums reicht und wie Sie einen aus dem Namen abgeleiteten Vertrag stabil halten.

Sie haben jeden Typ und jeden Member umbenannt, den geschützten Build ausgeliefert, und Ihre Datenschicht lief weiter: Abfragen wurden ausgeführt, Zeilen kamen zurück. Dann tauchte still eine Spalte namens a auf. Das Lambda, das Sie Ihrem ORM übergeben, o => o.Total, kompilierte weiterhin und lief weiterhin; die Umbenennung hat es nicht gebrochen. Sie tat etwas Subtileres: Sie reichte ins Innere des Expression Trees und änderte den Namen, den das ORM wieder herausliest.

Das ist der Teil der Umbenennung, den man übersieht. Ein Expression-Tree-Lambda ist kein Code wie ein Delegate — es ist eine kleine Datenstruktur, die Ihr Programm zur Laufzeit aufbaut, und die Umbenennung schreibt die darin enthaltenen Referenzen genauso um wie Referenzen überall sonst. Genau deshalb löst der Baum weiterhin auf. Und genau deshalb erhält auch alles, was einen Namen aus dem Baum zieht, den neuen.

Die eigentliche Frage

Wozu kompiliert o => o.Total tatsächlich, wenn sein Typ Expression<Func<Order, decimal>> ist, und welche Teile berührt die Umbenennung? Beantworten Sie das, und die Spalte namens a hört auf, ein Rätsel zu sein.

Wozu das Lambda kompiliert

Nehmen wir den einfachsten möglichen Fall:

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

Einem Delegate zugewiesen, wäre c => c.Name ein Methodenrumpf, der die Property liest. Expression<Func<...>> zugewiesen, emittiert der Compiler etwas völlig anderes: ein Rezept, das die Fabrikmethoden von Expression aufruft, um den Baum zu bauen. Hier ist das tatsächliche IL von 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

Zwei Zeilen entscheiden hier alles über das Verhalten der Umbenennung, und sie sind grundverschieden.

Der Member-Zugriff ist ein Token. IL_0016: ldtoken method instance string Customer::get_Name() lädt ein Metadaten-Token des Property-Getters, das GetMethodFromHandle zu einem MethodInfo auflöst, das Expression.Property in einen MemberExpression verwandelt. Der Getter wird so referenziert, wie jede Methodenreferenz in der Assembly referenziert wird — über ein Metadaten-Handle, nicht über seine Schreibweise.

Der Parametername ist eine Zeichenfolge. IL_000a: ldstr "c" schiebt das Literal "c" in Expression.Parameter. Diese Zeichenfolge ist der Anzeigename des Lambda-Parameters. Es sind reine Daten im #US-Heap, ohne Verbindung zu irgendetwas.

c => c.Name aus Fabrikaufrufen gebaut, kein MethodenrumpfMember-ZugriffExpression.Property(p, mi)ldtoken get_NameMetadaten-TOKEN, keine ZeichenfolgeParameterExpression.Parameter(t, "c")ldstr "c"String-LITERAL, nur AnzeigenameUmbenennungs-Pass — schreibt Referenzen um, lässt Literaleget_Name → get_a (Token-Ziel umgeschrieben)"c" unberührt (keine Referenz)Laufzeit: der Baum löst weiterhin auf — doch der abgeleitete NAME hat sich bewegtlambda.Compile()(order) → liest die richtige Property ✓((MemberExpression)body).Member.Name → "a"→ Spalte "a", nicht "Total"
Der Member-Zugriff ist ein Metadaten-Token, das die Umbenennung zusammen mit dem Member umschreibt; der Parametername ist ein inertes Literal. Der Baum löst korrekt auf, aber Member.Name liest nun den umbenannten Namen.

Warum die Umbenennung den Member erreicht, aber nicht das Verhalten des Lambdas

Die Umbenennung schreibt Referenzen um. Das ldtoken Customer::get_Name() ist eine Referenz, also schreibt der Umbenenner, wenn er Name in a verwandelt — die Property und ihren Getter get_Name zu get_a umbenennt — dieses Token so um, dass es auf get_a zeigt. Der zur Laufzeit neu aufgebaute Expression Tree enthält nun einen MemberExpression, dessen Member die umbenannte Property ist. Kompilieren Sie den Baum und rufen Sie ihn auf: Er liest das richtige Backing-Field. An der Ausführung bricht nichts, denn der Baum hing nie am Text "Name", um den Member zu finden — er hielt ein Handle.

Das ldstr "c" ist keine Referenz, also lässt der Umbenenner es in Ruhe, was harmlos ist: Der Anzeigename des Parameters ist kosmetisch.

Woher kommt dann "a"? Von Member.Name. MemberExpression.Member ist ein MemberInfo, und MemberInfo.Name liefert den aktuellen Metadaten-Namen des Members — nach der Umbenennung "a". Jeder Code, der den Baum durchläuft, um einen Namen zu extrahieren, liest den umbenannten:

// Ein typischer Helfer zum „Namen aus dem Lambda ableiten" — das Muster, das
// ORMs, Validatoren und Mapper intern verwenden:
static string MemberName<T, TP>(Expression<Func<T, TP>> e) =>
    ((MemberExpression)e.Body).Member.Name;   // war "Total", jetzt "a"

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

Das Lambda kompilierte. Das Lambda lief. Die daraus gewonnene Zeichenfolge änderte sich — und diese Zeichenfolge war Ihr Spaltenname, Ihr JSON-Schlüssel oder der Feldname in einer Validierungsmeldung.

Gegenüberstellung: Die Delegate-Form hat nichts zu brechen

Weisen Sie dasselbe Lambda einem Delegate zu, und der Compiler emittiert einen gewöhnlichen Methodenrumpf:

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

Die Umbenennung schreibt das Ziel des callvirt zu get_a um; die Methode läuft problemlos; kein Name wird aus irgendetwas abgeleitet. Das Risiko ist spezifisch für die Expression-Tree-Form, denn nur diese Form verwandelt den Member-Zugriff in Daten, die eine Bibliothek nach ihrem Namen inspizieren kann.

Wie Sie den Vertrag stabil halten

Zwei Lösungen, und die zweite ist vorzuziehen.

Schließen Sie die zugeordneten Member von der Umbenennung aus. Wenn die Property-Namen eines Typs die Quelle der Wahrheit für einen externen Vertrag sind, halten Sie diese Namen in Nebula.NET stabil und lassen Sie alles andere umbenennen:

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

Jetzt ergibt o => o.Total nach dem Schutz Member.Name == "Total", und der abgeleitete Spaltenname ist korrekt. Der Preis ist, dass diese Property-Namen lesbar bleiben — akzeptabel für eine Handvoll Persistenzfelder — und der Rest des Typs wird weiterhin umbenannt.

Legen Sie den Vertrag fest, damit er nicht mehr vom Namen abhängt. Die tiefere Lösung besteht darin, die externe Zeichenfolge gar nicht mehr aus dem Member-Namen abzuleiten. Geben Sie der Zuordnung einen expliziten Namen — [Column("Total")], .HasColumnName("Total"), [JsonPropertyName("total")] — und der Vertrag ist festgelegt, unabhängig davon, wie der Member heißt. Dann können Sie die Property frei umbenennen, denn nichts liest ihren Namen, um den Vertrag zu bauen:

modelBuilder.Entity<Order>()
    .Property(o => o.Total)
    .HasColumnName("Total");   // festgelegt — überlebt die Umbenennung, Member darf "a" werden

Das ist strikt besserer Schutz: Der Property-Name trägt keine Last mehr, Sie können ihn also obfuskieren.

Vorbehalte

  • Der Parametername leckt als Literal. ldstr "c" ist kosmetisch, aber ein aussagekräftiger Parametername (customerOrder) liegt im Klartext im #US-Heap. Aktivieren Sie encryptStrings, falls es Ihnen wichtig ist, auch wenn er wenig verrät.
  • Kompilierte und aufgerufene Bäume sind immer in Ordnung. Wenn Sie nur .Compile() ausführen und das Lambda aufrufen, ist die Umbenennung transparent — ignorieren Sie all das. Das Risiko betrifft ausschließlich die Ableitung von Namen.
  • Ausschlüsse müssen über den Graphen hinweg konsistent sein. Wenn das Lambda in einer Assembly und die Entität in einer anderen lebt, müssen beide zusammen geschützt werden, damit die Token-Umschreibung kohärent bleibt; ein Keep-List-Eintrag muss den Member in der Assembly benennen, die ihn tatsächlich definiert.
  • Die Zeichenfolgenverschlüsselung hilft hier nicht. Der Name ist ein aufgelöstes MemberInfo, kein Literal — die Verschlüsselung berührt ihn nie. Verwenden Sie Ausschlüsse oder explizite Zuordnung.

Fazit

Die Umbenennung ist nicht blind gegenüber Expression Trees; sie durchdringt sie und schreibt die Member-Token darin so um, dass der Baum weiterhin auflöst und das Lambda weiterhin läuft. Was sich bewegt, ist jeder Name, den Sie wieder aus dem Baum herauslesen: Member.Name liefert den aktuellen, umbenannten Namen, sodass ORMs, Serializer und Validatoren, die eine Zeichenfolge aus x => x.Prop ableiten, still den obfuskierten Namen auszugeben beginnen. Schließen Sie die wenigen Member aus, deren Namen ein Vertrag sind, oder — besser — legen Sie den Vertrag mit einem expliziten Attribut oder einer Zuordnung fest, damit der Member-Name kein Gewicht trägt und Sie ihn wie alles andere obfuskieren können.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.