using, instruction (référence C#)

L’instruction using fournit une syntaxe pratique qui garantit l’utilisation correcte des IDisposable objets. L’instruction await using garantit l’utilisation correcte des IAsyncDisposable objets. Le langage prend en charge les types jetables asynchrones qui implémentent l’interface System.IAsyncDisposable .

Exemple

L’exemple suivant montre comment utiliser l’instruction using.

string manyLines = @"This is line one
This is line two
Here is line three
The penultimate line is line four
This is the final, fifth line.";

using (var reader = new StringReader(manyLines))
{
    string? item;
    do
    {
        item = reader.ReadLine();
        Console.WriteLine(item);
    } while (item != null);
}

La déclaration using ne nécessite pas d’accolades :

string manyLines = @"This is line one
This is line two
Here is line three
The penultimate line is line four
This is the final, fifth line.";

using var reader = new StringReader(manyLines);
string? item;
do
{
    item = reader.ReadLine();
    Console.WriteLine(item);
} while (item != null);

Remarques

File et Font sont des exemples de types managés qui accèdent à des ressources non managées (dans le cas présent, des handles de fichiers et des contextes d’appareil). Beaucoup d’autres types de ressources non managées et de bibliothèques de classes peuvent les encapsuler. Tous ces types doivent implémenter l’interface IDisposable , ou l’interface IAsyncDisposable .

Lorsque la durée de vie d’un IDisposable objet est limitée à une seule méthode, vous devez le déclarer et l’instancier dans l’instruction ou using la using déclaration. La using déclaration appelle la Dispose méthode sur l’objet de la manière correcte lorsqu’elle sort de l’étendue. L’instruction using entraîne la sortie de l’objet lui-même de l’étendue dès qu’il Dispose est appelé. Dans le using bloc, l’objet est en lecture seule et ne peut pas être modifié ou réaffecté. Une variable déclarée avec une using déclaration est en lecture seule. Si l’objet implémente IAsyncDisposable au lieu de , l’un ou l’autre usingIDisposableformulaire appelle le DisposeAsync et awaits le retournéValueTask. Pour plus d’informations sur IAsyncDisposable, consultez Implémenter une méthode DisposeAsync.

Les deux using formulaires garantissent que Dispose (ou DisposeAsync) est appelé même si une exception se produit dans le using bloc. Vous pouvez obtenir le même résultat en plaçant l’objet à l’intérieur d’un try bloc, puis en appelant Dispose (ou DisposeAsync) dans un finally bloc ; en fait, c’est ainsi que l’instruction using et la using déclaration sont traduites par le compilateur. L’exemple de code précédent se développe pour donner le code suivant au moment de la compilation (notez les accolades supplémentaires pour créer la portée limitée de l’objet) :

string manyLines = @"This is line one
This is line two
Here is line three
The penultimate line is line four
This is the final, fifth line.";

{
    var reader = new StringReader(manyLines);
    try
    {
        string? item;
        do
        {
            item = reader.ReadLine();
            Console.WriteLine(item);
        } while (item != null);
    }
    finally
    {
        reader?.Dispose();
    }
}

La syntaxe d’instruction la plus récente using se traduit en code similaire. Le try bloc s’ouvre là où la variable est déclarée. Le finally bloc est ajouté à la fin du bloc englobant, généralement à la fin d’une méthode.

Pour plus d’informations sur l’instruction try-finally , consultez l’article try-finally .

Plusieurs instances d’un type peuvent être déclarées dans une seule using instruction, comme illustré dans l’exemple suivant. Notez que vous ne pouvez pas utiliser de variables implicitement typées (var) lorsque vous déclarez plusieurs variables dans une seule instruction :

string numbers = @"One
Two
Three
Four.";
string letters = @"A
B
C
D.";

using (StringReader left = new StringReader(numbers),
    right = new StringReader(letters))
{
    string? item;
    do
    {
        item = left.ReadLine();
        Console.Write(item);
        Console.Write("    ");
        item = right.ReadLine();
        Console.WriteLine(item);
    } while (item != null);
}

Vous pouvez également combiner plusieurs déclarations du même type à l’aide de la syntaxe de déclaration, comme illustré dans l’exemple suivant :

string numbers = @"One
Two
Three
Four.";
string letters = @"A
B
C
D.";

using StringReader left = new StringReader(numbers),
    right = new StringReader(letters);
string? item;
do
{
    item = left.ReadLine();
    Console.Write(item);
    Console.Write("    ");
    item = right.ReadLine();
    Console.WriteLine(item);
} while (item != null);

Vous pouvez instancier l’objet de ressource, puis passer la variable à l’instruction using , mais ce n’est pas une bonne pratique. Dans ce cas, une fois que le contrôle a quitté le bloc using, l’objet reste dans la portée mais n’a probablement pas accès à ses ressources non managées. En d’autres termes, il n’est plus complètement initialisé. Si vous essayez d’utiliser l’objet à l’extérieur du bloc using, vous risquez de provoquer la levée d’une exception. Pour cette raison, il est préférable d’instancier l’objet dans l’instruction using et de limiter son étendue au using bloc.

string manyLines = @"This is line one
This is line two
Here is line three
The penultimate line is line four
This is the final, fifth line.";

var reader = new StringReader(manyLines);
using (reader)
{
    string? item;
    do
    {
        item = reader.ReadLine();
        Console.WriteLine(item);
    } while (item != null);
}
// reader is in scope here, but has been disposed

Pour plus d’informations sur la suppression d’objets IDisposable, consultez Utilisation d’objets qui implémentent IDisposable.

spécification du langage C#

Pour plus d’informations, consultez Instruction using dans la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi