Using vs Try-Finally

Fait partie de la section Logique & Flux du Journey C# de Coddy — leçon 28 sur 66.

Les instructions using et les blocs try-finally aident à gérer les ressources qui doivent être correctement libérées. L'instruction using fournit une manière plus propre et plus concise d'assurer que les objets IDisposable sont correctement libérés.

Regardons d'abord une approche try-finally. Ici, StreamReader est une classe qui lit du texte à partir d'un fichier — elle maintient un descripteur de fichier ouvert, qui est une ressource qui doit être libérée lorsque nous avons terminé :

StreamReader reader = null;
try
{
    reader = new StreamReader("file.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}
finally
{
    if (reader != null)
    {
        reader.Dispose();
    }
}

Le bloc finally garantit que Dispose() est appelé pour libérer le descripteur de fichier, même si une exception se produit à l'intérieur du bloc try.

L'instruction using simplifie ce motif. Elle déclare et initialise la ressource entre parenthèses, et appelle automatiquement Dispose() lorsque le bloc se termine — que ce soit normalement ou en raison d'une exception :

using (StreamReader reader = new StreamReader("file.txt"))
{
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}

Ceci est équivalent à l'exemple try-finally ci-dessus, mais avec moins de code boilerplate.

La déclaration using appelle automatiquement Dispose() lorsque le bloc se termine, même si une exception se produit. Elle remplace le modèle de nettoyage try-finally — pas try-catch. Si vous avez également besoin de gérer les exceptions, vous pouvez toujours envelopper un bloc using dans un try-catch.

Défi

Facile

Créez une méthode nommée processFile qui :

Prend un nom de fichier comme paramètre string
Utilise l'instruction using avec un StreamReader pour lire toutes les lignes du fichier
Retourne le nombre de lignes dans le fichier
Si une FileNotFoundException se produit, affichez "File not found" et retournez -1

Aide-mémoire

L'instruction using fournit un nettoyage automatique des ressources pour les objets IDisposable, garantissant que Dispose() est appelée même si des exceptions se produisent. Elle remplace le modèle verbeux try-finally.

Approche try-finally :

StreamReader reader = null;
try
{
    reader = new StreamReader("file.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}
finally
{
    if (reader != null)
    {
        reader.Dispose();
    }
}

Instruction using (approche plus propre) :

using (StreamReader reader = new StreamReader("file.txt"))
{
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}

Les deux approches garantissent que Dispose() est appelée lorsque le bloc se termine. L'instruction using gère cela automatiquement, supprimant le besoin d'une vérification manuelle de null et d'un bloc finally.

Points clés :
• using remplace try-finally — pas try-catch
• try-catch peut toujours être combiné avec using pour gérer les exceptions
• StreamReader lit les fichiers texte et implémente IDisposable, le rendant idéal pour une utilisation avec using

Essayez vous-même

using System;
using System.IO;

class ProcessFile
{
    public static int processFile(string filename)
    {
        // Écrivez votre code ici
    }
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Using vs Try-Finally

Aide-mémoire

Toutes les leçons de Logique & Flux