Cómo decompilar una DLL de .NET a C# (guía 2026)

Para decompilar una DLL de .NET de vuelta a C#, abre el ensamblado en un decompilador de .NET como Glass.NET, ILSpy o dotPeek — la herramienta lee el IL y los metadatos dentro de la DLL y reconstruye C# legible que puedes examinar, buscar y exportar como proyecto. No se requieren archivos de código fuente, PDB ni una compilación especial; basta con un .dll o .exe administrado estándar.

Eso funciona por cómo está construido .NET, y lleva unos dos minutos. Aquí tienes el porqué, el cómo, y una mirada honesta a qué herramienta elegir.

Por qué los ensamblados de .NET se decompilan tan limpiamente

Un ensamblado de .NET no es código máquina. Cuando compilas un proyecto de C#, el compilador emite Lenguaje Intermedio Común (CIL, o simplemente IL) — un conjunto de instrucciones compacto y basado en pila — más una rica tabla de metadatos que describe cada tipo, método, campo, propiedad y parámetro por nombre y firma. Ese IL y esos metadatos son lo que se distribuye dentro del .dll o .exe. El código nativo real no se produce hasta el tiempo de ejecución, cuando el compilador JIT (just-in-time) convierte el IL en instrucciones máquina para la CPU actual.

Ese diseño es estupendo para la portabilidad, pero también significa que la DLL lleva una descripción casi completa de tu programa. Los nombres de tipos y métodos sobreviven. Las firmas sobreviven. El flujo de control es totalmente recuperable a partir del IL. El trabajo de un decompilador es esencialmente ejecutar el compilador de C# al revés: leer el IL, hacer coincidir sus patrones con construcciones del lenguaje C# (un foreach, un método async, una consulta LINQ), y presentar el resultado con formato.

Por eso .NET sin ofuscar se decompila de forma mucho más legible que, digamos, un binario de C++. Los metadatos hacen la mayor parte del trabajo. También es por eso que existe la ofuscación — pero más sobre eso luego.

Decompilar una DLL a C#, paso a paso

El flujo de trabajo es el mismo entre herramientas. Aquí lo tienes en Glass.NET, con notas sobre dónde difieren otros decompiladores.

1. Abre el ensamblado

Lanza el decompilador y abre tu .dll o .exe (en Glass: Archivo ▸ Abrir ensamblado, o arrástralo a la ventana). La herramienta carga los metadatos del ensamblado y lo lista en un árbol. No necesitas el código fuente ni un PDB a juego — aunque si hay un PDB presente, algunas herramientas lo usan para recuperar los nombres de variables locales originales.

2. Examina el árbol de tipos

Expande el ensamblado para ver sus espacios de nombres ▸ tipos ▸ miembros. Esto refleja la estructura que registró el compilador. Haz clic en cualquier tipo para decompilarlo bajo demanda — los decompiladores trabajan de forma perezosa, reconstruyendo C# para el miembro que seleccionas en lugar del ensamblado completo de antemano, lo que mantiene receptivas las bibliotecas grandes.

3. Lee el C# (y el IL)

Al seleccionar un método se muestra el C# reconstruido. La mayoría de las herramientas, Glass incluido, te permiten cambiar el mismo miembro entre una vista de C# y una vista de IL en crudo — útil cuando el C# parece sorprendente y quieres confirmar lo que el IL hace realmente. Glass renderiza el código en un editor (AvaloniaEdit) con plegado y resaltado de sintaxis, y admite navegación como Ir a la definición y Buscar todas las referencias para que puedas moverte por un ensamblado desconocido como te moverías por tu propio código fuente en lugar de desplazarte.

4. Exporta a un proyecto compilable

Cuando quieres el código en disco — para hacer diff, grep, o abrirlo en Visual Studio — exporta. En la GUI esto suele ser Archivo ▸ Exportar a proyecto, que escribe un .csproj más los archivos .cs reconstruidos. Glass también tiene una interfaz de línea de comandos, así que puedes guionizarlo:

# Export a decompiled assembly to a C# project
glass export MyLibrary.dll --output ./MyLibrary.Source

# Generate a software bill of materials for an assembly
glass sbom MyLibrary.dll

(Ejecuta glass --help o un subcomando con --help para ver las opciones exactas de tu compilación.) Un ensamblado pequeño normalmente se recompila directamente; uno grande u ofuscado puede necesitar correcciones manuales antes de compilar — las referencias sin resolver y las construcciones generadas por el compilador son los culpables habituales.

ILSpy frente a dnSpy frente a dotPeek frente a Glass.NET

Todas estas son herramientas legítimas y ampliamente usadas. Aquí tienes una lectura justa de cada una.

ILSpy es el caballo de batalla de código abierto del mundo de los decompiladores de .NET. Su motor de decompilación, ICSharpCode.Decompiler (con licencia MIT), es genuinamente excelente y se mantiene al día con las nuevas funciones del lenguaje C#. Muchas otras herramientas — Glass incluido — construyen sobre él. Si quieres un lector gratuito, sin florituras y fiable, y te sientes cómodo con una interfaz minimalista, ILSpy es una gran opción por defecto.

dnSpy / dnSpyEx hace algo que los demás no: depura ensamblados administrados e incluso puede editarlos y reensamblarlos. Ese es un trabajo distinto al de leer código, y para la depuración en vivo de un binario sigue siendo insuperable. La pega es que el dnSpy original está archivado y ya no se mantiene; la comunidad lo lleva adelante como dnSpyEx. Recurre a él cuando necesites específicamente un depurador.

dotPeek, de JetBrains, es un decompilador gratuito sólido y un ajuste natural si ya estás en el ecosistema de JetBrains — se integra con ReSharper y puede actuar como servidor de símbolos. Usa el propio decompilador de JetBrains en lugar del motor de ILSpy.

Glass.NET es el decompilador gratuito de Delta1 Labs. Está construido sobre el mismo motor ICSharpCode.Decompiler que ILSpy, así que la precisión del C# está a la par — esto no es una afirmación de “nuestra decompilación es más lista”. En lo que Glass se centra es en la experiencia alrededor del código: una interfaz Avalonia nativa de VS con un editor de código real y temas claro/oscuro a juego, comparación de ensamblados en paralelo con diff línea a línea, exportación de SBOM, y comprobación de autenticidad de paquetes NuGet para que puedas confirmar que un paquete coincide con lo que publicó su autor. Se ejecuta sobre .NET 8, se distribuye para Windows (incluida una compilación de la Store MSIX), y tiene los subcomandos de CLI glass export y glass sbom. No es un depurador — si necesitas recorrer el código en tiempo de ejecución, ese es el territorio de dnSpyEx.

	Glass.NET	ILSpy	dnSpyEx	dotPeek
Precio	Gratuito	Gratuito	Gratuito	Gratuito
Motor	ICSharpCode.Decompiler	ICSharpCode.Decompiler	ICSharpCode.Decompiler	JetBrains
Examinar + leer C# / IL	✓	✓	✓	✓
Exportar a proyecto	✓	✓	✓	✓
Diff / comparación de ensamblados	✓	—	—	Parcial
Exportación de SBOM	✓	—	—	—
Comprobación de autenticidad de NuGet	✓	—	—	—
Depuración en vivo	—	—	✓	—
En desarrollo activo	✓	✓	Bifurcación comunitaria	✓

No hay un único “mejor” aquí — elige por flujo de trabajo. Si quieres la opción de código abierto más ligera, ILSpy. Si necesitas depurar, dnSpyEx. Si vives en las herramientas de JetBrains, dotPeek. Si quieres una experiencia de lectura rápida y moderna con diff, SBOM y verificación de paquetes, Glass. Para un desglose más profundo función por función, consulta Glass.NET frente a ILSpy, dnSpy y dotPeek.

La otra cara: proteger tu propio código

Si decompilar una DLL de vuelta a C# limpio es así de fácil, la pregunta obvia es: ¿qué le pasa a tu código cuando lo distribuyes? Por defecto, cualquiera con un decompilador puede leer tus algoritmos, comprobaciones de licencia y secretos casi tan claramente como los escribiste.

Para eso está la ofuscación. Nebula.NET es la suite de protección de .NET de Delta1 Labs — renombrado de identificadores, aplanado del flujo de control, cifrado de cadenas, anti-manipulación, y la virtualización de código Enterprise que compila los métodos sensibles a una VM de bytecode personalizada para que no quede IL que decompilar. Y como Glass y Nebula vienen del mismo sitio, puedes verificar el resultado tú mismo: protege una compilación con Nebula, ábrela en Glass, y confirma que los nombres han desaparecido, el flujo de control es ilegible, y los métodos virtualizados aparecen como una llamada a la VM en lugar de tu lógica. La mayoría de los proveedores no te entregan la herramienta para comprobar su propia salida.

¿Cuál deberías usar?

Para leer y entender un ensamblado — una dependencia de la que dependes, una compilación cuyo código fuente perdiste, una revisión de seguridad, o comprobar lo que un ofuscador produjo — cualquiera de estas herramientas gratuitas te dará C# preciso. Glass.NET es la que probar si quieres que esa experiencia de lectura se sienta como navegar tu propio proyecto, con diff, SBOM y comprobaciones de autenticidad integradas. Es gratuito para siempre, sin licencia ni registro.

Consíguelo en la página de descargas o en la página de producto de Glass.NET, abre una DLL, y lee el C# por ti mismo. Y si es tu código lo que te preocupa, decompílalo primero — luego decide si necesita Nebula.NET.