Hoe ziet de using-richtlijn eruit na compilatie?

De using-richtlijn genereert op zichzelf geen uitvoerbare code. Het wordt tijdens de compilatie door de compiler verwerkt en wordt voor verschillende doeleinden gebruikt:

Aanwijzing van gebruikte naamruimtes (usings for namespaces): Hiermee kan je types uit de aangegeven naamruimtes gebruiken zonder de volledige gekwalificeerde naam. Na compilatie bevatten de referenties naar de types in de IL-code de volledige gekwalificeerde namen (naamruimte + type naam).
```
// Voor compilatie:
using System;

// gebruik de Console-klasse zonder kwalificatie
Console.WriteLine("Hello"); 

// Na compilatie (in IL-code):
// aanroep van de methode System.Console::WriteLine(string)
```

Aliassen voor naamruimtes of types (using aliases): Maakt een kortere naam voor een naamruimte of type. In IL-code worden de originele volledige namen gebruikt, niet de aliassen.

// Voor compilatie:
using MyCustomType = MyProject.MyNamespace.SomeVeryLongTypeName;

MyCustomType instance = new MyCustomType();

// Na compilatie (in IL-code):
// aanmaken van een instantie van MyProject.MyNamespace.SomeVeryLongTypeName

Statische using (using static): Maakt het mogelijk om direct statische leden van een type aan te roepen zonder de naam van het type te specificeren. In IL-code bevat de aanroep de volledige naam van het type en de statische methode.
```
// Voor compilatie:
using static System.Math;

double result = Sqrt(16.0); // gebruik Math.Sqrt

// Na compilatie (in IL-code):
// aanroep van de statische methode System.Math::Sqrt(double)
```

using-directive (Statement block): Zorgt voor het juiste vrijmaken van resources die de interface IDisposable implementeren. De compiler genereert een try...finally-blok dat de Dispose()-methode van het object aanroept.

// Voor compilatie:
using (var stream = new System.IO.FileStream("file.txt", System.IO.FileMode.Open))
{
    // werken met de stream
} // Dispose() wordt hier aangeroepen

// Na compilatie (voorbeeld in IL-code):
/*
.try
{
    // maken van het stream-object
    // werken met de stream
}
finally
{
    // nullcontrole en aanroep van stream.Dispose()
}
*/

Dus, using-richtlijnen blijven niet als zodanig in de gecompileerde code. Ze beïnvloeden hoe de compiler de namen van types en leden resolveert (voor de eerste drie gevallen) en hoe de code wordt gegenereerd voor resourcebeheer (voor het laatste geval).