using statement – se till att disponibla objekt används korrekt

Instruktionen using säkerställer korrekt användning av en IDisposable instans:

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);
        }
    }
}

När kontrollen lämnar -blocket för -instruktionen using tas en förvärvad IDisposable instans bort. I synnerhet säkerställer instruktionen using att en disponibel instans tas bort även om ett undantag inträffar inom -blocket i -instruktionen using . I föregående exempel stängs en öppnad fil när alla rader har bearbetats.

Använd -instruktionen await using för att använda en IAsyncDisposable instans på rätt sätt:

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

Mer information om hur du använder IAsyncDisposable instanser finns i avsnittet Använda asynkron disponibel i artikeln Implementera en DisposeAsync-metod.

Du kan också använda en usingdeklaration som inte kräver klammerparenteser:

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;
}

När den deklareras i en using deklaration tas en lokal variabel bort i slutet av omfånget där den deklareras. I föregående exempel sker avyttring i slutet av en metod.

En variabel som deklareras av -instruktionen eller deklarationen using är skrivskyddad. Du kan inte omtilldela den eller skicka den som en ref eller out flera parametrar.

Du kan deklarera flera instanser av samma typ i en using -instruktion, som följande exempel visar:

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

När du deklarerar flera instanser i en using instruktion tas de bort i omvänd deklarationsordning.

Du kan också använda -instruktionen och deklarationen using med en instans av en referens-struct som passar engångsmönstret. Den har alltså en instansmetod Dispose som är tillgänglig, parameterlös och har en void returtyp.

En return i ett using block garanterar fortfarande bortskaffande, kompilatorn skriver om den till en try/finally, så resursens anropas Dispose alltid innan metoden faktiskt returnerar.

-instruktionen using kan också vara av följande formulär:

using (expression)
{
    // ...
}

där expression skapar en disponibel instans. Följande exempel visar att:

StreamReader reader = File.OpenText(filePath);

using (reader)
{
    // Process file content
}

Språkspecifikation för C#

Mer information finns i avsnittet Using statement (Använda instruktion ) i språkspecifikationen C#.

Se även

• System.IDisposable
• System.IAsyncDisposable
• Använda objekt som implementerar IDisposable
• Implementera en avyttra-metod
• Implementera en DisposeAsync-metod
• Använd enkel "using"-instruktion (formatregel IDE0063)
• using direktiv