Leer las instrucciones de nivel superior en C# decompilado
Un archivo de instrucciones de nivel superior no tiene ninguna clase visible ni ningún Main visible, pero el ensamblado sí. El compilador de C# envuelve tus instrucciones en una clase interna llamada Program y en un método de entrada con el nombre impronunciable <Main>$, marcado con la directiva .entrypoint. Esto es exactamente lo que emite el compilador en los casos síncrono y async, por qué el punto de entrada es el método que nunca puedes escribir a mano, adónde fueron a parar tus global usings y cómo Glass.NET lo lee de vuelta como el programa de nivel superior que escribiste.
Un archivo de C# que usa instrucciones de nivel superior parece no tener clase ni Main — simplemente escribes instrucciones y el programa se ejecuta. Pero un ensamblado tiene que tener un punto de entrada, y los metadatos tienen que nombrar un tipo donde colgarlo. El compilador aporta ambas cosas por ti, y cuando abres el resultado en un decompilador el andamiaje vuelve a hacerse visible: una clase llamada Program que nunca escribiste, y un método de entrada con un nombre que no puedes escribir.
Esta es una inmersión práctica en ese andamiaje: qué emite el compilador de C# para un programa de nivel superior tanto en el caso síncrono como en el async, la pista del .entrypoint que identifica el verdadero punto de entrada sin importar su nombre, adónde desaparecen tus directivas using y cómo Glass.NET lo lee todo de vuelta al programa de nivel superior con el que empezaste. Glass es un decompilador de .NET gratuito, y todo lo de aquí es puro análisis estático: leer metadatos e IL de un ensamblado que tienes derecho a inspeccionar, sin ejecutarlo nunca.
El código fuente
Tan sencillo como puede ser un programa de nivel superior: una instrucción y un código de salida:
using System;
Console.WriteLine($"args: {args.Length}");
return 0;
Sin espacio de nombres, sin clase, sin firma de método y, sin embargo, args está en ámbito y return establece el código de salida del proceso. Las tres cosas las dispone el compilador en tu nombre.
Qué emite el compilador
Las instrucciones se convierten en el cuerpo de un método que el compilador llama <Main>$, colocado en una clase sintetizada llamada Program. Decompilado de vuelta a C# legible, la forma generada es esta:
internal class Program
{
private static int <Main>$(string[] args)
{
Console.WriteLine($"args: {args.Length}");
return 0;
}
}
Merece la pena detenerse en dos detalles. La clase es internal (no static), así que lleva un constructor de instancia predeterminado aunque el propio punto de entrada sea static — un Program escrito a mano con un static Main suele ser una static class o tiene un constructor que elegiste, de modo que la sencilla internal class con un método con nombre del compilador es en sí misma una pista. Y el nombre del método, <Main>$, no es un identificador válido de C#: los corchetes angulares y el signo de dólar lo hacen impronunciable, por lo que nunca puede chocar con un Main que añadas y nunca puedes invocarlo por su nombre.
Aquí está el IL, donde vive el marcador decisivo:
.class private auto ansi beforefieldinit Program
extends [System.Runtime]System.Object
{
.method private hidebysig static int32
'<Main>$'(string[] args) cil managed
{
.entrypoint
.maxstack 8
ldstr "args: "
ldarg.0
ldlen
conv.i4
box [System.Runtime]System.Int32
call string [System.Runtime]System.String::Concat(object, object)
call void [System.Console]System.Console::WriteLine(string)
ldc.i4.0
ret
}
}
La directiva .entrypoint es la que importa. Exactamente un método en un ejecutable la lleva, y es lo que el CLR lee para decidir dónde comienza la ejecución. Un decompilador no necesita reconocer la convención de nombres <Main>$ para encontrar el punto de entrada — lee el token de punto de entrada de los metadatos directamente de la cabecera CLI y aterriza en este método. El nombre es una comodidad para los humanos; .entrypoint es la verdad de base.
Cuando el programa es async
Añade un await en cualquier parte de las instrucciones de nivel superior y el punto de entrada cambia de forma. Supón que el código fuente es:
using System;
using System.Threading.Tasks;
await Task.Delay(100);
Console.WriteLine("done");
return args.Length;
Como el cuerpo hace await y devuelve un int, el compilador emite <Main>$ como un método async Task<int> y lo traduce exactamente como cualquier método async: una estructura de máquina de estados generada contiene la lógica, y <Main>$ en sí se convierte en un arranque ligero. Decompilado, el método visible es solo esto:
[AsyncStateMachine(typeof(<<Main>$>d__0))]
[DebuggerStepThrough]
private static Task<int> <Main>$(string[] args)
{
<<Main>$>d__0 stateMachine = default;
stateMachine.args = args;
stateMachine.<>t__builder =
AsyncTaskMethodBuilder<int>.Create();
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
El flujo de control real — el await, la continuación tras Task.Delay, el retorno — vive en <<Main>$>d__0.MoveNext(), el mismo patrón de máquina de estados [CompilerGenerated] que se usa para cada método async. Lo único especial es el nombre base alterado <Main>$ hilvanado en el propio nombre de la máquina de estados, <<Main>$>d__0. El runtime sigue arrancando en el envoltorio síncrono <Main>$, que las reglas del lenguaje C# adaptan discretamente a un punto de entrada async por ti.
Adónde fueron las directivas using
Una cosa que no encontrarás en los metadatos son tus directivas using — y menos aún las globales. Los using implícitos (<ImplicitUsings>enable</ImplicitUsings>) y las directivas global using explícitas son una comodidad de enlace en tiempo de compilación; resuelven nombres de tipo durante la compilación y no emiten metadatos ni IL. Para cuando el ensamblado existe, cada referencia de tipo ya está totalmente cualificada en las tablas de metadatos.
Así que el bloque using System; que ves en lo alto de la salida de Glass no es una copia del código fuente original — es la propia reconstrucción de Glass, calculada a partir de las referencias totalmente cualificadas que el método realmente usa. Ese es el modelo mental correcto para todas las listas de using decompiladas: se regeneran para que la salida compile y se lea con claridad, no se recuperan del código fuente. Leerlas como prueba de lo que el autor escribió es un error.
Cómo lo lee Glass
Un decompilador ingenuo se detiene en la verdad literal: una internal class Program con un método llamado <Main>$. Eso es exacto pero incómodo — el nombre entre corchetes angulares no vuelve a C# compilable, y el andamiaje oscurece las tres líneas que te importan.
Glass.NET reconoce el patrón — el método .entrypoint, la convención de nombres <Main>$ y el contenedor Program sintetizado — y te ofrece el programa tal como se escribió: como instrucciones de nivel superior, con el return mapeado al código de salida y args presentado como el parámetro en ámbito. Cuando el punto de entrada es async, Glass pliega el arranque y la máquina de estados <<Main>$>d__0 de vuelta a las instrucciones con await, de modo que lees await Task.Delay(100) en lugar de un baile de builder. Siempre puedes bajar al IL en crudo y ver .entrypoint por ti mismo cuando quieras confirmar con qué arranca realmente el runtime.
La conclusión práctica
Cuando abras un ejecutable y el punto de entrada parezca extraño — una internal class Program que no habrías escrito, un método llamado <Main>$ o un breve envoltorio async delante de una estructura <<Main>$>d__0 — estás mirando instrucciones de nivel superior ordinarias, no nada exótico. Encuentra el método marcado con .entrypoint, lee su cuerpo (o deja que Glass lo pliegue a forma de nivel superior) e ignora el bloque de using reconstruido como andamiaje más que como código fuente. Glass.NET es gratuito y hace esto puramente leyendo los metadatos y el IL del ensamblado, así que puedes inspeccionar qué hace realmente al arrancar un programa que tienes derecho a analizar — sin ejecutarlo nunca.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.