1. Comment bien libérer les ressources en C# ?
Imagine l'OS comme un bibliothécaire super strict. Tu prends un livre (t'ouvres un fichier/flux), tu lis, et puis... t'oublies de le rendre ! Le bibliothécaire râle : "Quoi ?! Le livre est encore chez toi ?!" Bah c'est pareil avec les flux. Un flux ouvert prend des ressources : un descripteur de fichier, un bout de mémoire, et en plus il bloque le fichier pour les autres applis.
Si tu fermes pas le flux, ça peut aller de "y'a un truc qui marche pas" à "tout est cassé, personne peut écrire dans ce fichier". Et si t'as plein de flux pas fermés dans ton programme — le système peut commencer à "fuir" niveau ressources et juste s'arrêter de marcher.
Où est le danger ?
- Le fichier n'est pas fermé, les commandes n'arrivent pas jusqu'au disque (par exemple, en écriture — les données peuvent rester dans le buffer).
- Le fichier est bloqué pour les autres process — tes collègues et les autres applis vont râler.
- Limite de descripteurs : sous Windows/Linux, les process ont une limite de fichiers/flux ouverts.
Interface IDisposable
Toute classe qui bosse avec des ressources non managées (flux, fichiers, bases de données, sockets), doit implémenter l'interface IDisposable.
public interface IDisposable
{
void Dispose();
}
Dans la méthode Dispose(), en général, on libère toutes les ressources malheureuses : le fichier est enfin fermé, les connexions sont coupées, la mémoire est libérée.
Les flux — c'est des objets qui tiennent en main plein de ressources importantes : fichiers, connexions, mémoire. Si tu les fermes pas, le fichier peut rester bloqué (ton Word va te dire "fichier ouvert par une autre appli !"), et le système — sans mémoire. Donc c'est super important de libérer le flux quand t'as fini.
En .NET, les flux implémentent l'interface IDisposable. Ça veut dire : faut les fermer en appelant Dispose() (ou juste les mettre dans un bloc using).
2. Façons de fermer un flux : du risqué au fiable
Option 1. Fermeture "à la main" : fais pas ça !
C'est la vieille méthode. Même si je l'ai montrée dans les exemples d'avant, en dev moderne, quasi personne fait comme ça :P
var stream = new FileStream("file.txt", FileMode.Open);
// On bosse avec le flux
stream.Close(); // ou stream.Dispose()
Le souci : si entre l'ouverture et la fermeture y'a une erreur/exception, le fichier reste ouvert et bloqué. C'est comme si tu sortais de la bibliothèque avec le livre sous le bras, parce que t'as senti l'odeur de la pizza...
Option 2. On utilise try...finally
FileStream stream = null;
try
{
stream = new FileStream("file.txt", FileMode.Open);
// On bosse avec le flux
}
finally
{
if (stream != null)
stream.Dispose();
}
Cette option est fiable : finally s'exécutera même s'il y a une erreur. Mais, avoue, c'est relou à écrire.
Option 3. Propre et safe : l'opérateur using
Syntaxe classique (using ( ... ) { ... })
using (var stream = new FileStream("file.txt", FileMode.Open))
{
// On bosse avec le flux
}
// Ici stream.Dispose() sera appelé automatiquement !
L'idée clé — tout ce qui est dans le bloc using bosse avec le flux, et quand le bloc se termine — le fichier est fermé même si y'a eu un souci (genre une exception).
Option 4. Syntaxe moderne
Syntaxe moderne (using var)
using var stream = new FileStream("file.txt", FileMode.Open);
// On bosse avec le flux
// ... Dispose sera appelé automatiquement quand la variable sortira du scope
Trop cool ! Pas besoin de rajouter des accolades et des indentations pour rien.
Comment ça marche "sous le capot" ?
L'opérateur using est transformé par le compilateur en ce fameux try...finally, mais pour toi. Blague : "using écrit du code propre à ta place — bientôt il va boire du café et scroller sur Stack Overflow ?".
Différence entre le using classique et moderne
| Bloc using classique | using var (déclaration) | |
|---|---|---|
| Look | |
|
| Portée | Dans les accolades du bloc | Jusqu'à la fin du bloc courant (méthode, boucle, etc.) |
| Brièveté | Un peu plus verbeux | Concise, moins d'indentation |
| Depuis | C# 1.0 | C# 8.0 et plus |
3. C'est quoi les using-déclarations ?
Il y a 5 ans, le monde a vu une nouvelle façon concise de bosser avec les objets IDisposable.
using-déclaration — c'est quand tu déclares une variable avec le mot-clé using au lieu d'un bloc, et elle sera libérée automatiquement à la fin du bloc courant (genre méthode ou boucle), pas à la fin des accolades d'un bloc supplémentaire.
using var stream = new FileStream("file.txt", FileMode.Open);
// On bosse avec le flux
Console.WriteLine(stream.Length);
// Ici le fichier est encore ouvert !
// ... fin de la méthode
// stream.Dispose() sera appelé ici automatiquement
Diffs clés avec le using classique :
- Pas besoin d'accolades, pas de bloc de code imbriqué.
- La variable est dispo jusqu'à la fin de tout le bloc où elle est déclarée (en général — la méthode, parfois — la boucle, la classe si c'est déclaré au niveau classe).
- La libération de la ressource se fait seulement quand le bloc d'exécution se termine.
Pourquoi c'est cool ?
- Moins de niveaux d'imbrication — le code est beaucoup plus court et lisible.
- Plus simple de gérer plusieurs ressources — déclare plusieurs variables using à la suite, tout sera libéré à la fin de la méthode.
- Moins de risques de se planter — tu risques pas d'oublier la zone où tu devais appeler Dispose().
4. Comparons : using classique vs. moderne
Regarde la comparaison en code.
Méthode classique
using (var reader = new StreamReader("input.txt"))
{
using (var writer = new StreamWriter("output.txt"))
{
string line;
while ((line = reader.ReadLine()) != null)
{
writer.WriteLine(line.ToUpper());
}
}
} // Ici les deux fichiers seront fermés
Méthode moderne (C# 8+)
using var reader = new StreamReader("input.txt");
using var writer = new StreamWriter("output.txt");
string line;
while ((line = reader.ReadLine()) != null)
{
writer.WriteLine(line.ToUpper());
}
// Les deux fichiers seront fermés ici, à la sortie de la méthode
Ça a l'air plus simple, non ? Surtout si tu fais encore plus d'imbrication — la méthode moderne te simplifie grave la vie.
5. Quand et où Dispose() est appelé ?
Ici, souvent les étudiants se plantent : ils pensent que Dispose sera appelé juste après la ligne d'utilisation — mais non !
Regarde cet exemple :
void MyMethod()
{
using var fileStream = new FileStream("data.bin", FileMode.Open);
// ... plein de code, peut-être même des boucles et des appels imbriqués
// fileStream est encore ouvert !
// Ici tu peux encore accéder à fileStream
}
// Ici, au } de la méthode, fileStream.Dispose() est appelé
Point important : Si tu déclares une variable using dans une boucle, Dispose sera appelé après chaque itération.
foreach (var path in filePaths)
{
using var reader = new StreamReader(path);
// on bosse avec reader
} // reader.Dispose() sera appelé après chaque itération (ferme le fichier)
6. Erreurs en migrant du vieux code
Parfois, tu migres du vieux code ou tu copies un exemple avec le using classique, mais ta variable a besoin de "vivre" plus longtemps que la portée des accolades. Là, la version classique ne va pas, mais les using-déclarations — c'est parfait.
Mais y'a des subtilités. Par exemple, si dans une boucle t'as deux ressources, mais l'une doit "vivre" plus longtemps que l'autre — déclare-les dans le bon ordre :
using var resource1 = ...;
for (int i = 0; i < 10; i++)
{
using var resource2 = ...;
// resource2 vit une itération
// resource1 — toute la fonction
}
7. Pratique
On continue à améliorer notre appli d'apprentissage — un petit simulateur de commande de café que t'as pimpé les jours précédents. Maintenant, il va pouvoir sauvegarder l'historique des commandes dans un fichier texte et les lire au démarrage.
Étape 1 : On sauvegarde la commande dans un fichier
using var writer = new StreamWriter("orders.txt", append: true);
writer.WriteLine("Café : Latte ; Lait : Avoine ; Taille : Grand");
// Le deuxième paramètre du constructeur StreamWriter append: true indique qu'on veut ajouter, pas écraser le fichier.
Étape 2 : On lit l'historique des commandes
using var reader = new StreamReader("orders.txt");
string? line;
while ((line = reader.ReadLine()) != null)
{
Console.WriteLine($"Commande : {line}");
}
Et dès que le programme termine cette méthode, les fichiers seront fermés automatiquement.
8. Best practices avec les using-déclarations
1. Utilise toujours using pour les objets qui implémentent IDisposable
En .NET, la plupart des classes pour bosser avec fichiers, flux, ressources implémentent cette interface. C'est le signal : libère-moi avec using !
2. Pense à la portée : déclare pas un using-var là où la variable va "gêner"
Si la variable sert juste pour deux lignes — utilise-la là où il faut, pas avant.
3. N'oublie pas l'ordre de libération
Si tu déclares plusieurs variables using à la suite — Dispose sera appelé dans l'ordre inverse :
using var first = new Resource("Premier");
using var second = new Resource("Second");
// ... on bosse
// D'abord Dispose pour second, puis pour first
C'est parfois important, si une ressource dépend d'une autre (genre le flux d'écriture doit être libéré avant le fichier).
4. N'utilise pas la using-déclaration hors d'une méthode
Les using-déclarations sont interdites au niveau de la classe (genre pour les champs). Elles marchent seulement dans les méthodes, constructeurs, etc.
5. Combine avec la gestion d'erreurs
Même avec using, toutes les exceptions sont pas toujours cool — c'est malin de rajouter un try-catch si tu veux gérer les erreurs de lecture/écriture.
GO TO FULL VERSION