¿Using dentro o fuera del namespace? Impacto en el rendimiento de C#

Guerra de mundos: using dentro o fuera del namespace en C#

Si alguna vez has escrito en C#, seguramente has visto este debate en los comentarios o en Stack Overflow. Algunos desarrolladores escriben obstinadamente using dentro de namespace, otros lo hacen fuera. Y cada uno está seguro de que su enfoque es el único correcto. Pero, ¿quién tiene razón? Y lo más importante: ¿afecta esto al rendimiento de tu código?

Aclaremos esta cuestión de una vez por todas, miremos bajo el capó del compilador y descubramos qué sucede realmente con tus directivas using. Spoiler: la respuesta te sorprenderá.

¿Qué son las directivas using y para qué sirven?

Antes de sumergirnos en los detalles, recordemos lo básico. Las directivas using son tu pase al mundo de espacios de nombres ajenos. Sin ellas, tendrías que escribir cada vez los nombres completos calificados:

System.Console.WriteLine("¡Hola, mundo!");\nSystem.Collections.Generic.List<int> numbers = new System.Collections.Generic.List<int>();

¿De acuerdo? Se ve horrible. Las directivas using hacen que el código sea más limpio y legible:

using System;\nusing System.Collections.Generic;\n\nConsole.WriteLine("¡Hola, mundo!");\nList<int> numbers = new List<int>();

Pero dónde colocarlas es una cuestión que atormenta a generaciones de desarrolladores de C#.

Dos bandos: fuera vs dentro

Así es como se ven los dos enfoques:

Opción 1: using fuera del namespace

using System;\nusing System.Collections.Generic;\n\nnamespace MyApp\n{\n    class Program\n    {\n        static void Main()\n        {\n            List<int> list = new List<int>();\n        }\n    }\n}

Opción 2: using dentro del namespace

namespace MyApp\n{\n    using System;\n    using System.Collections.Generic;\n\n    class Program\n    {\n        static void Main()\n        {\n            List<int> list = new List<int>();\n        }\n    }\n}

A simple vista, la diferencia está solo en la sangría. Pero la comunidad se ha dividido en dos bandos irreconciliables. Analicemos los argumentos de cada uno.

Argumento n.º 1: Rendimiento y compilación

La pregunta más frecuente: ¿afecta la ubicación de using al rendimiento? Respuesta breve: NO. Y he aquí por qué.

Las directivas using son puro azúcar sintáctico para el compilador. Solo existen en la etapa de compilación. Cuando tu código se convierte en IL (Intermediate Language), no queda rastro de las directivas using. El compilador simplemente las usa para resolver los nombres de tipos y luego las descarta.

Demostrémoslo en la práctica. Consideremos este código:

// Archivo: Program.cs\nusing System;\nusing System.Collections.Generic;\n\nnamespace MyApp\n{\n    class Program\n    {\n        static void Main()\n        {\n            List<int> list = new List<int>();\n            Console.WriteLine(list.Count);\n        }\n    }\n}

Después de la compilación a código IL, verás algo como esto (muy simplificado):

.method private hidebysig static void Main() cil managed\n{\n    .entrypoint\n    .maxstack 1\n    .locals init (\n        [0] class [System.Runtime]System.Collections.Generic.List`1<int32> list\n    )\n    \n    // Creación de List<int>\n    newobj instance void class [System.Runtime]System.Collections.Generic.List`1<int32>::.ctor()\n    stloc.0\n    \n    // Llamada a Console.WriteLine\n    ldloc.0\n    callvirt instance int32 class [System.Runtime]System.Collections.Generic.List`1<int32>::get_Count()\n    call void [System.Console]System.Console::WriteLine(int32)\n    \n    ret\n}

Observa: en el código IL se usan nombres completos calificados (System.Collections.Generic.List`1,