Skip to content
← Todas las publicaciones
· Delta1 Labs VB.NETGlass

Decompilar un ensamblado VB.NET a C#

Una DLL de VB.NET no lleva código fuente ni etiqueta de lenguaje, pero el compilador de Visual Basic deja huellas por todo el IL: módulos estándar, ayudantes de enlace tardío, Operators.CompareString, el manejo de errores de ProjectData y el espacio de nombres My. Así lee Glass.NET esas huellas y reconstruye C# limpio y legible a partir de un binario que nunca fue C#, todo estático y todo gratis.

Heredas una .dll. Forma parte de una app de negocio que lleva quince años funcionando, el código fuente se vio por última vez en la máquina de un desarrollador que se dio de baja hace una década, y la única pista sobre su origen es que todos los que la recuerdan la llaman “el componente de VB”. La abres en un decompilador esperando Visual Basic, y sale C#: C# plagado de llamadas a tipos que nunca has escrito: NewLateBinding.LateGet, Operators.CompareString, Conversions.ToDouble, ProjectData.SetProjectError.

Eso no es que el decompilador se equivoque. Es que el decompilador es honesto. El CLR no tiene ni idea de que tu ensamblado fue en su día Visual Basic —los metadatos y el IL no llevan etiqueta de lenguaje fuente—, pero el compilador de VB dejó huellas por todas partes, y esas huellas son esas llamadas ayudantes. Este artículo recorre lo que el compilador de Visual Basic le hizo a tu código camino del IL, y cómo Glass.NET —el decompilador .NET gratuito y solo estático— convierte un binario que nunca fue C# en C# que de verdad puedes leer.

Los metadatos no tienen lenguaje; el compilador tiene acento

C# y Visual Basic apuntan ambos al mismo CLR. Cuando MSBuild termina, un proyecto VB y un proyecto C# producen el mismo tipo de archivo PE: un sistema de tipos descrito en tablas de metadatos, métodos descritos en IL. No hay un indicador de “esto era VB”. Por eso un decompilador siempre reconstruye C#, porque C# es el lenguaje que mejor se corresponde con los metadatos, y eso es justo lo que quieres cuando el objetivo es leer la cosa.

Pero cada compilador tiene un acento. El compilador de VB recurre al runtime de Visual Basic, Microsoft.VisualBasic.dll, para implementar funciones del lenguaje que el CLR no ofrece de forma nativa. Aprende a oír el acento y el C# decompilado deja de parecer extraño y empieza a contarte con precisión qué decía el VB original.

Los módulos se convierten en clases estáticas selladas

Un Module de VB no tiene equivalente directo en C#, así que el compilador lo reduce a una clase sellada cuyos miembros son todos static, marcada con un atributo. Este VB:

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

compila a un tipo que lleva Microsoft.VisualBasic.CompilerServices.StandardModuleAttribute, con el método emitido así:

.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 reconoce la marca StandardModule y la forma totalmente estática y reconstruye el equivalente idiomático en C# —una static class— en lugar de una rareza abstracta-sellada:

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

El atributo [StandardModule] se deja visible a propósito: es la huella más clara de que el original era un Module de VB, y ocultarlo borraría información que quizá necesites.

Enlace tardío: el impuesto de Option Strict Off

Nada identifica un ensamblado VB como el enlace tardío. Con el Option Strict Off por defecto, este VB es perfectamente legal:

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

doc está tipado como Object, y .Metadata.Title se resuelve en tiempo de ejecución por reflexión. C# necesitaría dynamic para esto, pero el compilador de VB no emite un sitio de llamada dynamic. Emite una llamada al enlazador tardío del runtime de Visual Basic. El IL de doc.Metadata.Title se convierte en dos llamadas a NewLateBinding.LateGet, y Glass las reconstruye fielmente:

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

Es verboso, pero es la verdad: cada acceso a un miembro sobre un Object de enlace tardío fue una búsqueda reflexiva, y el C# decompilado muestra exactamente eso. Cuando ves NewLateBinding.LateGet o LateCall, estás leyendo código escrito con Option Strict Off. Mentalmente, LateGet(x, null, "P", …) es solo ((dynamic)x).P; Glass te ofrece una opción de menú para colapsar las llamadas de enlace tardío reconocidas en accesos a miembros dynamic cuando prefieras leer la intención antes que el mecanismo.

La comparación de cadenas pasa por Operators.CompareString

En C#, a == b sobre dos cadenas es un string.Equals casi ordinal. En VB, el operador = sobre cadenas depende de Option Compare, y el compilador nunca emite una comparación directa. Emite Operators.CompareString, que toma un tercer argumento —TextCompare— que es false para Option Compare Binary y true para Option Compare Text (sin distinción de mayúsculas, sensible a la cultura). Así que este VB:

If status = "Active" Then Return True

decompila a:

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

El tercer argumento es oro diagnóstico. TextCompare: true significa que todo el módulo se compiló con Option Compare Text, y cada = sobre cadenas en él era una comparación sin distinción de mayúsculas, un comportamiento que querrías conservar con cuidado si alguna vez portas este código a C#, donde == se volvería silenciosamente sensible a mayúsculas. Glass muestra el indicador en lugar de descartarlo.

On Error se convierte en contabilidad de ProjectData

El manejo de errores no estructurado de VB —On Error Resume Next, On Error GoTo— no tiene ninguna instrucción IL detrás. El compilador sintetiza una máquina de estados alrededor del registro de errores ProjectData del runtime de Visual Basic. Un método con On Error Resume Next decompila a un esqueleto try/catch con ProjectData.SetProjectError(ex) en el catch y ProjectData.ClearProjectError() donde se reanuda el control, más un entero oculto que rastrea el objetivo de “resume”. Glass reconstruye el flujo de control con fidelidad —puedes ver qué sentencias estaban protegidas y dónde debía reanudarse la ejecución— aunque la palabra clave On Error original ya no esté. Ver ProjectData.SetProjectError en un bloque catch delata que el fuente usaba On Error, no Try/Catch.

La figura siguiente resume qué acento de VB corresponde a qué huella del runtime, y qué te muestra Glass en cada caso.

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

Conversiones implícitas y el espacio de nombres My

Dos huellas menores completan el cuadro. Primero, VB convierte de forma implícita donde C# se niega. Una expresión VB que asigna un String a un Double compila a Conversions.ToDouble(s) —el analizador tolerante del runtime de Visual Basic—, no a una conversión de tipo, y Glass muestra esa llamada para que sepas que estaba ocurriendo un análisis, no una conversión. Segundo, la función My (My.Application, My.Computer, My.Settings) es pura magia del compilador: el compilador de VB genera un tipo oculto MyProject con clases anidadas MyApplication, MyComputer y de configuración, y reescribe cada acceso My. en una propiedad sobre él. En el C# decompilado encontrarás una clase MyProject generada que nunca escribiste: ahí fue a parar My.

Leerlo con Glass

Abre el ensamblado en la GUI de Glass y recorre el árbol; los módulos de VB aparecen como las clases estáticas en que se convirtieron, y la referencia al runtime de Visual Basic figura entre las dependencias del ensamblado, lo que por sí solo confirma de un vistazo que el binario era VB. Para extraer un solo miembro desde la línea de comandos:

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

Añade --il para ver el IL en crudo junto al C# reconstruido, que es la forma más rápida de confirmar qué hacía una llamada a LateGet o CompareString en el original:

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

Cuando estés listo para trabajar sobre el conjunto —buscarlo con grep, apuntarle un analizador o conservarlo como referencia permanente— expórtalo a un proyecto C# compilable:

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

Obtienes un .csproj, archivos .cs reconstruidos y los recursos que se extraigan. Abierto en tu editor, un componente VB de quince años es ahora un proyecto C# que puedes leer, buscar y razonar: el primer paso real tanto para mantenerlo vivo como para portarlo hacia adelante.

Glass es estrictamente estático: lee metadatos, IL y blobs de recursos y reconstruye el código fuente, y nunca ejecuta el ensamblado. Eso hace que inspeccionar tu propio componente VB huérfano, una biblioteca de terceros con licencia, o código que analizas por interoperabilidad o seguridad sea a la vez seguro y sólido, y Glass es completamente gratis, sin licencia, sin asientos y sin registro.

Prueba Nebula.NET

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