Alternativa a ILSpy: cuando quieres más

Déjame empezar con algo que no siempre oyes de una empresa que distribuye una herramienta competidora: ILSpy es genuinamente bueno. Es gratuito, de código abierto, mantenido activamente, y su motor de decompilación es la referencia sobre la que el resto construimos. Si alguien me pide un decompilador de .NET gratuito y sólido y nada más, ILSpy es una respuesta completamente defendible.

Entonces, ¿por qué buscarías una alternativa? No porque ILSpy decompile mal — no lo hace. Normalmente es porque quieres más alrededor del código: una interfaz más fluida, una navegación más ajustada, un flujo de trabajo que se sienta como moverse por tu propio proyecto en lugar de examinar un árbol. Esta entrada es una mirada honesta a dónde la gente quiere más de ILSpy, y cómo se comparan las alternativas — incluyendo Glass.NET, en el que trabajo.

En resumen: la decompilación de ILSpy es excelente y su motor impulsa varias otras herramientas, Glass.NET incluido. Si estás contento con ILSpy, quédate. Si quieres una interfaz más parecida a Visual Studio y un flujo de trabajo centrado en la navegación sobre la misma calidad de decompilación, Glass.NET merece una mirada. Si vives en las herramientas de JetBrains, dotPeek encaja. Las tres son gratuitas.

En qué es estupendo ILSpy

Hay que reconocer lo que merece. ILSpy se gana su lugar:

• C# preciso y moderno. El motor ICSharpCode.Decompiler (con licencia MIT) se mantiene al día con las nuevas funciones del lenguaje — async/await, coincidencia de patrones, records, y más vuelven intactos.
• Gratuito y de código abierto. Sin coste, sin registro, y puedes leer el código fuente del propio decompilador.
• Mantenido activamente. A diferencia de dnSpy, que está archivado, ILSpy recibe actualizaciones continuas.
• Ligero y fiable. Hace el trabajo principal — examinar tipos, leer C# e IL, exportar un proyecto — sin mucha ceremonia.
• Una base compartida. Como el motor es abierto, herramientas como Glass construyen sobre él. Cuando usas Glass, estás obteniendo decompilación de calidad ILSpy con una interfaz distinta.

Ese último punto importa para toda esta comparación: esto no es una pelea sobre quién reconstruye C# con más precisión. En las herramientas que comparten motor, el C# es comparable. La pregunta es qué te da la herramienta alrededor del código.

Dónde la gente quiere más

Una y otra vez, las razones por las que la gente mira más allá de ILSpy tienen que ver con la experiencia, no con la precisión:

• Una interfaz más parecida a Visual Studio. La interfaz de ILSpy es funcional pero ligera. Los desarrolladores que pasan el día en VS a menudo quieren un editor que se vea y se comporte como el que ya conocen.
• Navegación que siga el ritmo. Leer un método es fácil. Entender cómo encaja un ensamblado grande significa saltar a definiciones, encontrar cada llamador, y no perder tu sitio. La gente quiere que eso se sienta instantáneo y cohesivo.
• Orientación en ensamblados grandes. Una ruta de navegación, un historial de navegación, y una apertura rápida difusa veloz hacen que un ensamblado de 3000 tipos se sienta navegable en lugar de abrumador.
• Detalles de comparación y exportación. Hacer diff de dos versiones de un ensamblado, o exportar un proyecto compilable limpio, a veces pide un poco más de pulido del que ofrece un lector ligero.

Ninguna de estas son críticas al trabajo principal de ILSpy. Todas son “quiero que la experiencia de lectura se sienta como mi IDE”.

Glass.NET: el mismo motor, una interfaz centrada en la navegación

Aquí tienes el argumento honesto de Glass.NET. Es gratuito, y está construido sobre el mismo motor ICSharpCode.Decompiler que ILSpy — así que el C# decompilado está a la par. No voy a decirte que nuestra decompilación es más lista, porque es el mismo motor. Lo que Glass añade es la experiencia:

• Una interfaz nativa de Visual Studio, basada en Avalonia con un editor de código real, plegado de código, resaltado de sintaxis, y temas claro y oscuro a juego.
• Ir a la definición (F12) y Buscar todas las referencias (Shift+F12), resueltas a partir del propio árbol sintáctico del decompilador, así que aterrizas en el símbolo correcto, no en una coincidencia de texto.
• Ir a todo (Ctrl+T) — apertura rápida difusa a través de cada tipo y miembro del ensamblado.
• Jerarquía de llamadas y de tipos para recorrer llamadores/llamados y tipos base/derivados.
• Rutas de navegación e historial de navegación, para que siempre sepas dónde estás y puedas retroceder.
• Vistas de C# e IL, y exportación a un proyecto compilable cuando quieres el código en disco.
• Solo análisis estático — Glass nunca ejecuta el ensamblado que inspecciona.

Si la decompilación de ILSpy es lo que te gusta pero es la experiencia de lectura de lo que quieres más, ese es exactamente el hueco que Glass está hecho para llenar. Hay un desglose completo función por función en Glass.NET frente a ILSpy, dnSpy y dotPeek.

dotPeek: la alternativa de JetBrains

La otra opción gratuita seria es dotPeek de JetBrains. A diferencia de Glass e ILSpy, usa el propio motor de decompilación de JetBrains en lugar de ICSharpCode.Decompiler. Se integra con ReSharper y puede actuar como servidor de símbolos, permitiendo a Visual Studio entrar en el código decompilado. Si ya trabajas en las herramientas de JetBrains, es un ajuste natural. Hay una comparación dedicada de alternativa a dotPeek si lo estás sopesando específicamente.

Una comparación rápida en paralelo

	ILSpy	Glass.NET	dotPeek
Precio	Gratuito	Gratuito	Gratuito
Motor	ICSharpCode.Decompiler	ICSharpCode.Decompiler	JetBrains
Calidad del C# decompilado	Excelente	Comparable (mismo motor)	Excelente
Interfaz / editor nativo de VS	Ligero	✓	✓ (ReSharper)
Ir a la definición / Buscar referencias	✓	✓	✓
Ir a todo difuso	✓	✓	✓
Jerarquía de llamadas / tipos	Parcial	✓	✓
Mantenido activamente	✓	✓	✓

La fila que más importa: la calidad del C# decompilado es comparable entre ILSpy y Glass porque es literalmente el mismo motor. Elige por interfaz y flujo de trabajo, no por decompilación.

Un ejemplo trabajado: navegar, no desplazarse

Supón que abres un ensamblado de 2000 tipos para entender cómo su PaymentProcessor valida la entrada. En un lector ligero expandes el árbol, encuentras el tipo, lees el método, luego buscas manualmente qué llama a Validate(). En una herramienta centrada en la navegación el flujo es: Ctrl+T, escribes PaymentProcessor, Enter; F12 sobre Validate para aterrizar en su definición; Shift+F12 para transmitir cada llamador a un panel de resultados:

private bool Validate(PaymentRequest req)
{
    if (req.Amount <= 0m) return false;
    if (string.IsNullOrEmpty(req.Currency)) return false;
    return _rules.All(rule => rule.IsSatisfiedBy(req));
}

F12 sobre IsSatisfiedBy te lleva a cada implementación de regla. Te estás moviendo por el ensamblado de la forma en que te mueves por tu propio proyecto — ese es el “más” que la gente normalmente busca.

Límites honestos

Elijas la herramienta que elijas, la decompilación es decompilación. Obtienes C# preciso de lo que el código hace, pero los comentarios han desaparecido, la mayoría de los nombres de variables locales se pierden a menos que un PDB los proporcione, y construcciones como las máquinas de estado async se reconstruyen en lugar de recuperarse literalmente. Y ninguno de ILSpy, Glass o dotPeek es un depurador en vivo — para eso, dnSpyEx es la herramienta mantenida por la comunidad. Analiza solo software que tengas derecho a inspeccionar.

Pruébalo tú mismo

Si ILSpy ya hace todo lo que necesitas, sigue usándolo — es una buena herramienta. Pero si te has sorprendido deseando que la experiencia de lectura se sintiera más como tu IDE, Glass.NET te da decompilación de calidad ILSpy con una interfaz nativa de Visual Studio y centrada en la navegación. Es gratuito — sin licencia, sin puestos, sin registro. Descárgalo, abre un ensamblado, y pulsa F12.