Décompiler un assembly VB.NET en C#
Une DLL VB.NET ne porte ni code source ni étiquette de langage, pourtant le compilateur Visual Basic laisse des empreintes partout dans l'IL : modules standard, assistants de liaison tardive, Operators.CompareString, la gestion d'erreurs de ProjectData et l'espace de noms My. Voici comment Glass.NET lit ces empreintes et reconstruit du C# propre et lisible à partir d'un binaire qui n'a jamais été du C#, tout en statique et tout gratuit.
Vous héritez d”une .dll. Elle fait partie d”une application métier qui tourne depuis quinze ans, le code source a été vu pour la dernière fois sur la machine d”un développeur mise au rebut il y a une décennie, et le seul indice sur son origine est que tous ceux qui s”en souviennent l”appellent « le composant VB ». Vous l”ouvrez dans un décompilateur en vous attendant à du Visual Basic, et c”est du C# qui sort : du C# truffé d”appels à des types que vous n”avez jamais écrits : NewLateBinding.LateGet, Operators.CompareString, Conversions.ToDouble, ProjectData.SetProjectError.
Ce n”est pas le décompilateur qui se trompe. C”est le décompilateur qui est honnête. Le CLR n”a aucune idée que votre assembly était autrefois du Visual Basic — les métadonnées et l”IL ne portent aucune étiquette de langage source —, mais le compilateur VB a laissé des empreintes partout, et ces empreintes sont ces appels d”assistants. Cet article parcourt ce que le compilateur Visual Basic a fait à votre code sur le chemin de l”IL, et comment Glass.NET — le décompilateur .NET gratuit et purement statique — transforme un binaire qui n”a jamais été du C# en C# que vous pouvez réellement lire.
Les métadonnées n”ont pas de langage ; le compilateur a un accent
C# et Visual Basic ciblent tous deux le même CLR. Quand MSBuild a terminé, un projet VB et un projet C# produisent le même type de fichier PE : un système de types décrit dans des tables de métadonnées, des méthodes décrites en IL. Il n”y a pas d”indicateur « ceci était du VB ». Un décompilateur reconstruit donc toujours du C#, car C# est le langage qui correspond le plus directement aux métadonnées — et c”est exactement ce que vous voulez quand le but est de lire la chose.
Mais chaque compilateur a un accent. Le compilateur VB fait appel au runtime Visual Basic, Microsoft.VisualBasic.dll, pour implémenter des fonctionnalités du langage que le CLR n”offre pas nativement. Apprenez à entendre l”accent et le C# décompilé cesse de paraître étrange et commence à vous dire précisément ce que disait le VB d”origine.
Les modules deviennent des classes statiques scellées
Un Module VB n”a pas d”équivalent direct en C#, le compilateur l”abaisse donc en une classe scellée dont tous les membres sont static, marquée d”un attribut. Ce VB :
Module Billing
Public Function NetTotal(gross As Double, taxRate As Double) As Double
Return gross / (1 + taxRate)
End Function
End Module
compile vers un type portant Microsoft.VisualBasic.CompilerServices.StandardModuleAttribute, avec la méthode émise ainsi :
.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 reconnaît le marqueur StandardModule et la forme entièrement statique et reconstruit l”équivalent C# idiomatique — une static class — plutôt qu”une curiosité abstract-sealed :
[StandardModule]
internal static class Billing
{
public static double NetTotal(double gross, double taxRate)
=> gross / (1.0 + taxRate);
}
L”attribut [StandardModule] est laissé visible à dessein : c”est l”empreinte la plus nette indiquant que l”original était un Module VB, et le masquer effacerait une information dont vous pourriez avoir besoin.
Liaison tardive : la taxe d”Option Strict Off
Rien ne signale un assembly VB comme la liaison tardive. Sous l”Option Strict Off par défaut, ce VB est parfaitement légal :
Public Function TitleOf(doc As Object) As String
Return doc.Metadata.Title
End Function
doc est typé Object, et .Metadata.Title est résolu à l”exécution par réflexion. C# aurait besoin de dynamic pour cela — mais le compilateur VB n”émet pas de site d”appel dynamic. Il émet un appel au lieur tardif du runtime Visual Basic. L”IL de doc.Metadata.Title devient deux appels à NewLateBinding.LateGet, et Glass les reconstruit fidèlement :
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));
}
C”est verbeux, mais c”est la vérité : chaque accès à un membre sur un Object à liaison tardive était une recherche par réflexion, et le C# décompilé le montre exactement. Quand vous voyez NewLateBinding.LateGet ou LateCall, vous lisez du code écrit avec Option Strict Off. Mentalement, LateGet(x, null, "P", …) est juste ((dynamic)x).P — Glass vous propose une option de menu pour replier les appels de liaison tardive reconnus en accès de membre dynamic lorsque vous préférez lire l”intention plutôt que le mécanisme.
La comparaison de chaînes passe par Operators.CompareString
En C#, a == b sur deux chaînes est un string.Equals quasi ordinal. En VB, l”opérateur = sur les chaînes dépend d”Option Compare, et le compilateur n”émet jamais de comparaison directe. Il émet Operators.CompareString, qui prend un troisième argument — TextCompare — valant false pour Option Compare Binary et true pour Option Compare Text (insensible à la casse, sensible à la culture). Donc ce VB :
If status = "Active" Then Return True
se décompile en :
if (Operators.CompareString(status, "Active", TextCompare: false) == 0)
return true;
Le troisième argument est une mine de diagnostic. TextCompare: true signifie que tout le module a été compilé avec Option Compare Text, et que chaque = sur chaîne qu”il contient était une comparaison insensible à la casse — un comportement que vous voudriez absolument préserver si vous portiez un jour ce code en C#, où == deviendrait silencieusement sensible à la casse. Glass fait ressortir l”indicateur plutôt que de le supprimer.
On Error devient de la comptabilité ProjectData
La gestion d”erreurs non structurée de VB — On Error Resume Next, On Error GoTo — n”a aucune instruction IL derrière elle. Le compilateur synthétise une machine à états autour du registre d”erreurs ProjectData du runtime Visual Basic. Une méthode avec On Error Resume Next se décompile en un squelette try/catch avec ProjectData.SetProjectError(ex) dans le catch et ProjectData.ClearProjectError() là où le contrôle reprend, plus un entier caché suivant la cible de « resume ». Glass reconstruit le flux de contrôle fidèlement — vous pouvez voir quelles instructions étaient protégées et où l”exécution devait reprendre — même si le mot-clé On Error d”origine a disparu. Voir ProjectData.SetProjectError dans un bloc catch trahit que le source utilisait On Error, pas Try/Catch.
La figure ci-dessous résume quel accent VB correspond à quelle empreinte du runtime, et ce que Glass vous montre dans chaque cas.
Conversions implicites et l”espace de noms My
Deux empreintes mineures complètent le tableau. Premièrement, VB convertit implicitement là où C# refuse. Une expression VB qui affecte un String à un Double compile vers Conversions.ToDouble(s) — l”analyseur tolérant du runtime Visual Basic — et non une conversion de type, et Glass montre cet appel pour que vous sachiez qu”un analyse, et non une conversion, était en cours. Deuxièmement, la fonctionnalité My (My.Application, My.Computer, My.Settings) est de la pure magie du compilateur : le compilateur VB génère un type caché MyProject avec des classes imbriquées MyApplication, MyComputer et de paramètres, et réécrit chaque accès My. en une propriété dessus. Dans le C# décompilé vous trouverez une classe MyProject générée que vous n”avez jamais écrite : c”est là qu”est passé My.
Le lire avec Glass
Ouvrez l”assembly dans l”interface de Glass et parcourez l”arbre ; les modules VB apparaissent comme les classes statiques qu”ils sont devenus, et la référence au runtime Visual Basic figure parmi les dépendances de l”assembly — ce qui confirme à lui seul, d”un coup d”œil, que le binaire était du VB. Pour extraire un seul membre depuis la ligne de commande :
glass decompile Legacy.Billing.dll --type Billing --member NetTotal
Ajoutez --il pour voir l”IL brut à côté du C# reconstruit, le moyen le plus rapide de confirmer ce que faisait un appel LateGet ou CompareString dans l”original :
glass decompile Legacy.Billing.dll --type Billing --member TitleOf --il
Quand vous êtes prêt à travailler sur l”ensemble — le passer au grep, y pointer un analyseur, ou le garder comme référence permanente — exportez-le vers un projet C# compilable :
glass export Legacy.Billing.dll --output ./Legacy.Billing.Source
Vous obtenez un .csproj, des fichiers .cs reconstruits et les ressources extraites. Ouvert dans votre éditeur, un composant VB de quinze ans est désormais un projet C# que vous pouvez lire, chercher et comprendre — le premier vrai pas, que ce soit pour le maintenir en vie ou pour le porter vers l”avenir.
Glass est strictement statique : il lit les métadonnées, l”IL et les blobs de ressources et reconstruit le code source, et n”exécute jamais l”assembly. Cela rend l”inspection de votre propre composant VB orphelin, d”une bibliothèque tierce sous licence, ou de code que vous analysez pour l”interopérabilité ou la sécurité à la fois sûre et fiable — et Glass est entièrement gratuit, sans licence, sans sièges et sans inscription.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.