instruction using : garantir l’utilisation correcte des objets supprimables

  • Article

L’instruction using garantit l’utilisation correcte d’une instance IDisposable :

var numbers = new List<int>();
using (StreamReader reader = File.OpenText("numbers.txt"))
{
    string line;
    while ((line = reader.ReadLine()) is not null)
    {
        if (int.TryParse(line, out int number))
        {
            numbers.Add(number);
        }
    }
}

Quand le contrôle quitte le bloc de l’instruction using, une instance IDisposable acquise est supprimée. En particulier, l’instruction using garantit qu’une instance supprimable est supprimée même si une exception se produit dans le bloc de l’instruction using. Dans l’exemple précédent, un fichier ouvert est fermé après le traitement de toutes les lignes.

Utilisez l’instruction await using pour utiliser correctement une instance IAsyncDisposable :

await using (var resource = new AsyncDisposableExample())
{
    // Use the resource
}

Pour plus d’informations sur l’utilisation d’instances IAsyncDisposable, consultez la section Utilisation de la suppression asynchrone de l’article Implémenter une méthode DisposeAsync.

Vous pouvez aussi utiliser une déclaration using qui ne nécessite pas d’accolades :

static IEnumerable<int> LoadNumbers(string filePath)
{
    using StreamReader reader = File.OpenText(filePath);
    
    var numbers = new List<int>();
    string line;
    while ((line = reader.ReadLine()) is not null)
    {
        if (int.TryParse(line, out int number))
        {
            numbers.Add(number);
        }
    }
    return numbers;
}

Quand elle est déclarée dans une déclaration using, une variable locale est supprimée à la fin de l’étendue dans laquelle elle est déclarée. Dans l’exemple précédent, la suppression se produit à la fin d’une méthode.

Une variable déclarée par l’instruction ou la déclaration using est en lecture seule. Vous ne pouvez pas la réaffecter ou la passer en tant que paramètre ref ou out.

Vous pouvez déclarer plusieurs instances du même type dans une instruction using, comme le montre l’exemple suivant :

using (StreamReader numbersFile = File.OpenText("numbers.txt"), wordsFile = File.OpenText("words.txt"))
{
    // Process both files
}

Quand vous déclarez plusieurs instances dans une instruction using, elles sont supprimées dans l’ordre inverse de déclaration.

Vous pouvez aussi utiliser l’instruction et la using déclaration avec une instance d’un struct ref qui correspond au modèle supprimable. Autrement dit, il doit avoir une méthode Dispose d’instance qui soit accessible et sans paramètre, avec un type de retour void.

L’instruction using peut également avoir la forme suivante :

using (expression)
{
    // ...
}

où expression produit une instance supprimable. L’exemple suivant illustre ce qui suit :

StreamReader reader = File.OpenText(filePath);

using (reader)
{
    // Process file content
}

Avertissement

Dans l’exemple précédent, une fois que le contrôle a quitté l’instruction using, une instance supprimable reste dans l’étendue alors qu’elle est déjà supprimée. Si vous utilisez cette instance plus loin, vous pouvez rencontrer une exception, par exemple ObjectDisposedException. C’est pourquoi nous vous recommandons de déclarer une variable supprimable dans l’instruction using ou avec la déclaration using.

spécification du langage C#

Pour plus d’informations, consultez la section L’instruction using de la spécification du langage C# et la note de proposition relative à « using basé sur un modèle » et « déclarations using ».

Voir aussi