Skip to content
← Alle Beiträge
· Delta1 Labs VB.NETGlass

Ein VB.NET-Assembly nach C# dekompilieren

Eine VB.NET-DLL trägt weder Quellcode noch eine Sprachkennung, doch der Visual-Basic-Compiler hinterlässt überall im IL Fingerabdrücke: Standardmodule, Late-Binding-Helfer, Operators.CompareString, die Fehlerbehandlung von ProjectData und den My-Namespace. So liest Glass.NET diese Fingerabdrücke und rekonstruiert sauberes, lesbares C# aus einem Binary, das nie C# war — alles statisch und alles kostenlos.

Sie erben eine .dll. Sie gehört zu einer Geschäftsanwendung, die seit fünfzehn Jahren läuft, der Quellcode wurde zuletzt auf dem Rechner eines Entwicklers gesehen, der vor einem Jahrzehnt ausgemustert wurde, und der einzige Hinweis auf ihre Herkunft ist, dass alle, die sich an sie erinnern, sie „die VB-Komponente” nennen. Sie öffnen sie in einem Dekompiler und erwarten Visual Basic — und heraus kommt C#: C#, übersät mit Aufrufen von Typen, die Sie nie geschrieben haben: NewLateBinding.LateGet, Operators.CompareString, Conversions.ToDouble, ProjectData.SetProjectError.

Das ist kein Fehler des Dekompilers. Das ist der Dekompiler, der ehrlich ist. Die CLR hat keine Ahnung, dass Ihr Assembly einst Visual Basic war — Metadaten und IL tragen keine Kennung der Quellsprache —, aber der VB-Compiler hat überall Fingerabdrücke hinterlassen, und diese Fingerabdrücke sind jene Helferaufrufe. Dieser Beitrag geht durch, was der Visual-Basic-Compiler auf dem Weg zum IL mit Ihrem Code gemacht hat, und wie Glass.NET — der kostenlose, rein statische .NET-Dekompiler — ein Binary, das nie C# war, in C# verwandelt, das Sie tatsächlich lesen können.

Metadaten haben keine Sprache; der Compiler hat einen Akzent

C# und Visual Basic zielen beide auf dieselbe CLR. Wenn MSBuild fertig ist, erzeugen ein VB-Projekt und ein C#-Projekt denselben Typ von PE-Datei: ein in Metadatentabellen beschriebenes Typsystem, in IL beschriebene Methoden. Es gibt kein Kennzeichen „das war VB”. Ein Dekompiler rekonstruiert daher immer C#, weil C# die Sprache ist, die sich am unmittelbarsten auf die Metadaten abbildet — und genau das wollen Sie, wenn das Ziel ist, das Ding zu lesen.

Aber jeder Compiler hat einen Akzent. Der VB-Compiler greift auf die Visual-Basic-Runtime, Microsoft.VisualBasic.dll, zurück, um Sprachmerkmale umzusetzen, die die CLR nicht nativ bietet. Lernen Sie, den Akzent zu hören, und das dekompilierte C# wirkt nicht mehr fremd, sondern sagt Ihnen genau, was das ursprüngliche VB aussagte.

Module werden zu versiegelten statischen Klassen

Ein VB-Module hat keine direkte Entsprechung in C#, daher senkt der Compiler es zu einer versiegelten Klasse ab, deren Mitglieder alle static sind und die mit einem Attribut markiert ist. Dieses VB:

Module Billing
    Public Function NetTotal(gross As Double, taxRate As Double) As Double
        Return gross / (1 + taxRate)
    End Function
End Module

kompiliert zu einem Typ, der Microsoft.VisualBasic.CompilerServices.StandardModuleAttribute trägt, mit der so emittierten Methode:

.class public auto ansi sealed Billing
    extends [System.Runtime]System.Object
{
  .custom instance void [Microsoft.VisualBasic]...StandardModuleAttribute::.ctor()
  .method public static float64 NetTotal(float64 gross, float64 taxRate) ...
}

Glass erkennt den StandardModule-Marker und die vollständig statische Form und rekonstruiert das idiomatische C#-Äquivalent — eine static class — statt einer abstract-sealed-Kuriosität:

[StandardModule]
internal static class Billing
{
    public static double NetTotal(double gross, double taxRate)
        => gross / (1.0 + taxRate);
}

Das Attribut [StandardModule] wird bewusst sichtbar belassen: Es ist der deutlichste Fingerabdruck dafür, dass das Original ein VB-Module war, und es zu verbergen würde Information löschen, die Sie vielleicht brauchen.

Late Binding: die Steuer von Option Strict Off

Nichts kennzeichnet ein VB-Assembly so wie Late Binding. Unter dem voreingestellten Option Strict Off ist dieses VB völlig legal:

Public Function TitleOf(doc As Object) As String
    Return doc.Metadata.Title
End Function

doc ist als Object typisiert, und .Metadata.Title wird zur Laufzeit per Reflexion aufgelöst. C# bräuchte dafür dynamic — aber der VB-Compiler emittiert keine dynamic-Aufrufstelle. Er emittiert einen Aufruf an den Late-Binder der Visual-Basic-Runtime. Das IL für doc.Metadata.Title wird zu zwei NewLateBinding.LateGet-Aufrufen, und Glass rekonstruiert sie getreu:

public static string TitleOf(object doc)
{
    object metadata = NewLateBinding.LateGet(
        doc, null, "Metadata", new object[0], null, null, null);
    return Conversions.ToString(
        NewLateBinding.LateGet(
            metadata, null, "Title", new object[0], null, null, null));
}

Das ist wortreich, aber es ist die Wahrheit: Jeder Mitgliedszugriff auf ein Late-Binding-Object war eine reflexive Suche, und das dekompilierte C# zeigt genau das. Wenn Sie NewLateBinding.LateGet oder LateCall sehen, lesen Sie Code, der mit Option Strict Off geschrieben wurde. Gedanklich ist LateGet(x, null, "P", …) einfach ((dynamic)x).P — Glass bietet Ihnen eine Menüoption, erkannte Late-Binding-Aufrufe zu dynamic-Mitgliedszugriffen zusammenzufalten, wenn Sie lieber die Absicht als den Mechanismus lesen.

Der Zeichenkettenvergleich läuft über Operators.CompareString

In C# ist a == b auf zwei Zeichenketten ein nahezu ordinales string.Equals. In VB hängt der =-Operator auf Zeichenketten von Option Compare ab, und der Compiler emittiert nie einen direkten Vergleich. Er emittiert Operators.CompareString, das ein drittes Argument nimmt — TextCompare —, das false für Option Compare Binary und true für Option Compare Text ist (Groß-/Kleinschreibung ignorierend, kulturabhängig). Dieses VB also:

If status = "Active" Then Return True

dekompiliert zu:

if (Operators.CompareString(status, "Active", TextCompare: false) == 0)
    return true;

Das dritte Argument ist diagnostisches Gold. TextCompare: true bedeutet, dass das ganze Modul mit Option Compare Text kompiliert wurde und jedes = auf Zeichenketten darin ein Vergleich ohne Beachtung der Groß-/Kleinschreibung war — ein Verhalten, das Sie unbedingt bewahren wollten, falls Sie diesen Code je nach C# portieren, wo == stillschweigend zwischen Groß- und Kleinschreibung unterscheiden würde. Glass hebt das Kennzeichen hervor, statt es wegzulassen.

On Error wird zur ProjectData-Buchführung

Die unstrukturierte Fehlerbehandlung von VB — On Error Resume Next, On Error GoTo — hat keine IL-Anweisung dahinter. Der Compiler synthetisiert einen Zustandsautomaten rund um das ProjectData-Fehlerregister der Visual-Basic-Runtime. Eine Methode mit On Error Resume Next dekompiliert zu einem try/catch-Gerüst mit ProjectData.SetProjectError(ex) im catch und ProjectData.ClearProjectError() dort, wo die Steuerung wieder aufsetzt, plus einer verborgenen Ganzzahl, die das „Resume”-Ziel verfolgt. Glass rekonstruiert den Kontrollfluss getreu — Sie können sehen, welche Anweisungen geschützt waren und wo die Ausführung fortsetzen sollte —, auch wenn das ursprüngliche On Error-Schlüsselwort verschwunden ist. ProjectData.SetProjectError in einem catch-Block zu sehen, verrät eindeutig, dass der Quelltext On Error verwendete, nicht Try/Catch.

Die folgende Abbildung fasst zusammen, welcher VB-Akzent welchem Runtime-Fingerabdruck entspricht und was Glass Ihnen in jedem Fall zeigt.

VB featureruntime fingerprintGlass shows C#ModuleStandardModuleAttributestatic classlate bindingNewLateBinding.LateGetLateGet(...) / dynamicOption CompareOperators.CompareStringCompareString(...) == 0On Error Resume NextProjectData.SetProjectErrortry / catch skeletonimplicit conversionConversions.ToDoubleConversions.ToDouble(x)

Implizite Konvertierungen und der My-Namespace

Zwei kleinere Fingerabdrücke runden das Bild ab. Erstens konvertiert VB implizit, wo C# sich weigert. Ein VB-Ausdruck, der ein String einem Double zuweist, kompiliert zu Conversions.ToDouble(s) — dem toleranten Parser der Visual-Basic-Runtime — und nicht zu einer Typumwandlung, und Glass zeigt diesen Aufruf, damit Sie wissen, dass ein Parsen und keine Umwandlung stattfand. Zweitens ist das My-Merkmal (My.Application, My.Computer, My.Settings) reine Compilermagie: Der VB-Compiler erzeugt einen verborgenen MyProject-Typ mit verschachtelten MyApplication-, MyComputer- und Einstellungsklassen und schreibt jeden My.-Zugriff in eine Eigenschaft darauf um. Im dekompilierten C# finden Sie eine generierte MyProject-Klasse, die Sie nie geschrieben haben — dorthin ist My gegangen.

Es mit Glass lesen

Öffnen Sie das Assembly in der Glass-Oberfläche und durchsuchen Sie den Baum; VB-Module erscheinen als die statischen Klassen, zu denen sie wurden, und die Referenz auf die Visual-Basic-Runtime steht unter den Abhängigkeiten des Assemblys — was für sich genommen auf einen Blick bestätigt, dass das Binary VB war. Um ein einzelnes Mitglied von der Kommandozeile zu ziehen:

glass decompile Legacy.Billing.dll --type Billing --member NetTotal

Fügen Sie --il hinzu, um das rohe IL neben dem rekonstruierten C# zu sehen — der schnellste Weg, um zu bestätigen, was ein LateGet- oder CompareString-Aufruf im Original tat:

glass decompile Legacy.Billing.dll --type Billing --member TitleOf --il

Wenn Sie bereit sind, am Ganzen zu arbeiten — es per grep durchsuchen, einen Analyzer darauf richten oder es als dauerhafte Referenz behalten —, exportieren Sie es in ein baubares C#-Projekt:

glass export Legacy.Billing.dll --output ./Legacy.Billing.Source

Sie erhalten ein .csproj, rekonstruierte .cs-Dateien und alle extrahierten Ressourcen. In Ihrem Editor geöffnet, ist eine fünfzehn Jahre alte VB-Komponente nun ein C#-Projekt, das Sie lesen, durchsuchen und verstehen können — der erste echte Schritt, egal ob Sie es am Leben halten oder voranportieren wollen.

Glass ist streng statisch: Es liest Metadaten, IL und Ressourcen-Blobs und rekonstruiert den Quellcode und führt das Assembly niemals aus. Das macht das Inspizieren Ihrer eigenen verwaisten VB-Komponente, einer lizenzierten Drittanbieterbibliothek oder von Code, den Sie zur Interoperabilität oder Sicherheit analysieren, zugleich sicher und solide — und Glass ist vollständig kostenlos, ohne Lizenz, ohne Plätze und ohne Anmeldung.

Nebula.NET testen

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