Skip to content
← Alle Beiträge
· Delta1 Labs Glass.NETDekompilierung.NETTiefenanalyse

Top-Level-Anweisungen in dekompiliertem C# lesen

Eine Datei mit Top-Level-Anweisungen hat keine sichtbare Klasse und kein sichtbares Main, die Assembly aber schon. Der C#-Compiler verpackt deine Anweisungen in eine interne Klasse namens Program und in eine Einstiegsmethode mit dem unaussprechlichen Namen <Main>$, markiert durch die Direktive .entrypoint. Hier steht genau, was der Compiler im synchronen und im async-Fall emittiert, warum der Einstiegspunkt die Methode ist, die du niemals von Hand schreiben kannst, wohin deine global usings verschwunden sind und wie Glass.NET das Ganze als das Top-Level-Programm zurückliest, das du geschrieben hast.

Eine C#-Datei, die Top-Level-Anweisungen verwendet, sieht so aus, als hätte sie keine Klasse und kein Main — du schreibst einfach Anweisungen, und das Programm läuft. Aber eine Assembly muss einen Einstiegspunkt haben, und die Metadaten müssen einen Typ benennen, an dem er hängt. Der Compiler liefert beides für dich, und wenn du das Ergebnis in einem Dekompilierer öffnest, wird das Gerüst wieder sichtbar: eine Klasse namens Program, die du nie geschrieben hast, und eine Einstiegsmethode mit einem Namen, den du nicht schreiben kannst.

Dies ist ein praktischer Tiefgang in dieses Gerüst: was der C#-Compiler für ein Top-Level-Programm im synchronen wie im async-Fall emittiert, der .entrypoint-Hinweis, der den echten Einstiegspunkt unabhängig von seinem Namen identifiziert, wohin deine using-Direktiven verschwinden und wie Glass.NET das Ganze zurück zu dem Top-Level-Programm liest, mit dem du begonnen hast. Glass ist ein kostenloser .NET-Dekompilierer, und alles hier ist reine statische Analyse: Metadaten und IL aus einer Assembly lesen, die du einsehen darfst, ohne sie jemals auszuführen.

Der Quelltext

So schlicht, wie ein Top-Level-Programm nur sein kann: eine Anweisung und ein Exit-Code:

using System;

Console.WriteLine($"args: {args.Length}");
return 0;

Kein Namespace, keine Klasse, keine Methodensignatur — und dennoch ist args im Gültigkeitsbereich und return setzt den Exit-Code des Prozesses. Alle drei Dinge richtet der Compiler in deinem Namen ein.

Was der Compiler emittiert

Die Anweisungen werden zum Rumpf einer Methode, die der Compiler <Main>$ nennt und auf einer synthetisierten Klasse namens Program platziert. Zurück in lesbares C# dekompiliert, hat die generierte Form diese Gestalt:

internal class Program
{
    private static int <Main>$(string[] args)
    {
        Console.WriteLine($"args: {args.Length}");
        return 0;
    }
}

Zwei Details lohnen den genaueren Blick. Die Klasse ist internal (nicht static), trägt also einen Standard-Instanzkonstruktor, obwohl der Einstiegspunkt selbst static ist — ein handgeschriebenes Program mit einem static Main ist üblicherweise eine static class oder hat einen von dir gewählten Konstruktor, sodass die schlichte internal class mit einer Methode mit Compiler-Namen schon für sich ein Hinweis ist. Und der Methodenname <Main>$ ist kein gültiger C#-Bezeichner: die spitzen Klammern und das Dollarzeichen machen ihn unaussprechlich, sodass er niemals mit einem von dir hinzugefügten Main kollidieren kann und du ihn niemals namentlich aufrufen kannst.

Hier ist das IL, wo der entscheidende Marker lebt:

.class private auto ansi beforefieldinit Program
       extends [System.Runtime]System.Object
{
  .method private hidebysig static int32
          '<Main>$'(string[] args) cil managed
  {
    .entrypoint
    .maxstack  8
    ldstr      "args: "
    ldarg.0
    ldlen
    conv.i4
    box        [System.Runtime]System.Int32
    call       string [System.Runtime]System.String::Concat(object, object)
    call       void [System.Console]System.Console::WriteLine(string)
    ldc.i4.0
    ret
  }
}

Die Direktive .entrypoint ist die entscheidende. Genau eine Methode in einer ausführbaren Datei trägt sie, und sie ist das, was die CLR liest, um zu entscheiden, wo die Ausführung beginnt. Ein Dekompilierer muss die Namenskonvention <Main>$ gar nicht erkennen, um den Einstiegspunkt zu finden — er liest das Einstiegspunkt-Token der Metadaten direkt aus dem CLI-Header und landet auf dieser Methode. Der Name ist eine Bequemlichkeit für Menschen; .entrypoint ist die Grundwahrheit.

Top-Level-QuelltextConsole.WriteLine(x);return 0;keine Klasse · kein Mainkompilierte Metadateninternal class Programint32 <Main>$(string[]) .entrypointunaussprechlicher NameEinsprung-Token (CLI)zeigt direkt auf <Main>$Glass-RekonstruktionConsole.WriteLine(x);return 0;Top-Level-Anweisungen

Wenn das Programm async ist

Füge an beliebiger Stelle in den Top-Level-Anweisungen ein await hinzu, und der Einstiegspunkt ändert seine Gestalt. Angenommen, der Quelltext lautet:

using System;
using System.Threading.Tasks;

await Task.Delay(100);
Console.WriteLine("done");
return args.Length;

Weil der Rumpf await verwendet und einen int zurückgibt, emittiert der Compiler <Main>$ als eine async Task<int>-Methode und übersetzt sie genau wie jede andere async-Methode: eine generierte Zustandsmaschinen-Struktur enthält die Logik, und <Main>$ selbst wird zu einem leichten Anstoß. Dekompiliert ist die sichtbare Methode nur dies:

[AsyncStateMachine(typeof(<<Main>$>d__0))]
[DebuggerStepThrough]
private static Task<int> <Main>$(string[] args)
{
    <<Main>$>d__0 stateMachine = default;
    stateMachine.args = args;
    stateMachine.<>t__builder =
        AsyncTaskMethodBuilder<int>.Create();
    stateMachine.<>1__state = -1;
    stateMachine.<>t__builder.Start(ref stateMachine);
    return stateMachine.<>t__builder.Task;
}

Der eigentliche Kontrollfluss — das await, die Fortsetzung nach Task.Delay, der Rücksprung — lebt in <<Main>$>d__0.MoveNext(), dasselbe [CompilerGenerated]-Zustandsmaschinenmuster, das für jede async-Methode verwendet wird. Das einzig Besondere daran ist der umbenannte Basisname <Main>$, der in den eigenen Namen der Zustandsmaschine eingeflochten ist, <<Main>$>d__0. Die Runtime startet weiterhin bei der synchronen Hülle <Main>$, die die Regeln der Sprache C# für dich still zu einem async-Einstiegspunkt anpassen.

Wohin die using-Direktiven verschwunden sind

Eine Sache, die du in den Metadaten nicht finden wirst, sind deine using-Direktiven — und am allerwenigsten die globalen. Implizite usings (<ImplicitUsings>enable</ImplicitUsings>) und explizite global using-Direktiven sind eine Binde-Bequemlichkeit zur Compile-Zeit; sie lösen Typnamen während der Kompilierung auf und emittieren weder Metadaten noch IL. Zu dem Zeitpunkt, an dem die Assembly existiert, ist jeder Typverweis bereits voll qualifiziert in den Metadatentabellen.

Der using System;-Block, den du oben in Glass’ Ausgabe siehst, ist also keine Kopie des ursprünglichen Quelltexts — er ist Glass’ eigene Rekonstruktion, berechnet aus den voll qualifizierten Verweisen, die die Methode tatsächlich verwendet. Das ist das richtige mentale Modell für alle dekompilierten using-Listen: sie werden neu erzeugt, damit die Ausgabe kompiliert und klar lesbar ist, nicht aus dem Quelltext wiederhergestellt. Sie als Beleg dafür zu lesen, was der Autor geschrieben hat, ist ein Fehler.

Wie Glass sie zurückliest

Ein naiver Dekompilierer bleibt bei der wörtlichen Wahrheit stehen: eine internal class Program mit einer Methode namens <Main>$. Das ist korrekt, aber unhandlich — der Name in spitzen Klammern lässt sich nicht zu kompilierbarem C# zurückführen, und das Gerüst verdeckt die drei Zeilen, die dich interessieren.

Glass.NET erkennt das Muster — die .entrypoint-Methode, die Namenskonvention <Main>$ und den synthetisierten Program-Container — und bietet dir das Programm so an, wie es geschrieben wurde: als Top-Level-Anweisungen, mit dem return auf den Exit-Code abgebildet und args als Parameter im Gültigkeitsbereich dargestellt. Wenn der Einstiegspunkt async ist, faltet Glass den Anstoß und die Zustandsmaschine <<Main>$>d__0 zurück in die Anweisungen, die await verwenden, sodass du await Task.Delay(100) liest statt eines Builder-Tanzes. Du kannst jederzeit auf das rohe IL hinabsteigen und .entrypoint selbst sehen, wenn du bestätigen willst, womit die Runtime tatsächlich startet.

Das praktische Fazit

Wenn du eine ausführbare Datei öffnest und der Einstiegspunkt seltsam aussieht — eine internal class Program, die du nicht geschrieben hättest, eine Methode namens <Main>$ oder eine kurze async-Hülle vor einer Struktur <<Main>$>d__0 —, dann siehst du gewöhnliche Top-Level-Anweisungen, nichts Exotisches. Finde die mit .entrypoint markierte Methode, lies ihren Rumpf (oder lass Glass sie in die Top-Level-Form falten) und ignoriere den rekonstruierten using-Block als Gerüst statt als Quelltext. Glass.NET ist kostenlos und tut dies rein durch das Lesen der Metadaten und des IL der Assembly, sodass du einsehen kannst, was ein Programm, das du analysieren darfst, beim Start wirklich tut — ohne es jemals auszuführen.

Nebula.NET testen

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