À quoi ressemble la directive using après la…

La directive using en elle-même ne génère pas de code exécutable. Elle est traitée par le compilateur lors de la compilation et sert à plusieurs fins :

Indication des espaces de noms utilisés (usings for namespaces) : Permet d'utiliser des types provenant des espaces de noms indiqués sans leur nom complet qualifié. Après compilation, les références aux types dans le code IL contiennent les noms complets qualifiés (espace de noms + nom du type).
```
// Avant compilation :
using System;

// utiliser la classe Console sans qualification
Console.WriteLine("Hello"); 

// Après compilation (dans le code IL) :
// appel à la méthode System.Console::WriteLine(string)
```

Alias pour les espaces de noms ou types (using aliases) : Crée un nom plus court pour un espace de noms ou un type. En code IL, on utilise les noms complets originaux, pas les alias.

// Avant compilation :
using MyCustomType = MyProject.MyNamespace.SomeVeryLongTypeName;

MyCustomType instance = new MyCustomType();

// Après compilation (dans le code IL) :
// création d'une instance de MyProject.MyNamespace.SomeVeryLongTypeName

Using statique (using static) : Permet d'appeler directement les membres statiques du type sans spécifier le nom du type. En IL, l'appel contiendra le nom complet du type et de la méthode statique.

// Avant compilation :
using static System.Math;

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

// Après compilation (dans le code IL) :
// appel à la méthode statique System.Math::Sqrt(double)

Directive using (bloc d'instruction) : Assure la libération correcte des ressources implémentant l'interface IDisposable. Le compilateur génère un bloc try...finally qui appelle la méthode Dispose() de l'objet.

// Avant compilation :
using (var stream = new System.IO.FileStream("file.txt", System.IO.FileMode.Open))
{
    // travail avec le flux
} // Dispose() est appelé ici

// Après compilation (exemple en code IL) :
/*
.try
{
    // création de l'objet stream
    // travail avec le flux
}
finally
{
    // vérification de null et appel à stream.Dispose()
}
*/

Ainsi, les directives using ne restent pas dans le code compilé telles quelles. Elles influencent la façon dont le compilateur résout les noms de types et de membres (pour les trois premiers cas) et la génération du code pour la gestion des ressources (pour le dernier cas).

À quoi ressemble la directive using après la compilation?