Theusing statement ensures the correct use of anIDisposable instance:

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

When the control leaves the block of theusing statement, an acquiredIDisposable instance is disposed. In particular, theusing statement ensures that a disposable instance is disposed even if an exception occurs within the block of theusing statement. In the preceding example, an opened file is closed after all lines are processed.

Use theawait using statement to correctly use anIAsyncDisposable instance:

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

For more information about using ofIAsyncDisposable instances, see theUsing async disposable section of theImplement a DisposeAsync method article.

You can also use ausingdeclaration that doesn't require braces:

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

When declared in ausing declaration, a local variable is disposed at the end of the scope in which it's declared. In the preceding example, disposal happens at the end of a method.

A variable declared by theusing statement or declaration is readonly. You cannot reassign it or pass it as aref orout parameter.

You can declare several instances of the same type in oneusing statement, as the following example shows:

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

When you declare several instances in oneusing statement, they are disposed in reverse order of declaration.

You can also use theusing statement and declaration with an instance of aref struct that fits the disposable pattern. That is, it has an instanceDispose method, which is accessible, parameterless and has avoid return type.

Theusing statement can also be of the following form:

using (expression){    // ...}

whereexpression produces a disposable instance. The following example demonstrates that:

StreamReader reader = File.OpenText(filePath);using (reader){    // Process file content}

C# language specification

For more information, seeThe using statement section of theC# language specification and the proposal note about"pattern-based using" and "using declarations".

See also

• System.IDisposable
• System.IAsyncDisposable
• Using objects that implement IDisposable
• Implement a Dispose method
• Implement a DisposeAsync method
• Use simple 'using' statement (style rule IDE0063)
• using directive