Using Statement

The using statement in C# is a control flow construct that ensures the deterministic release of resources by automatically invoking a disposal method. It defines a strict lexical scope at the end of which the target object is safely disposed. To be compatible with the synchronous using statement, a type must be implicitly convertible to the System.IDisposable interface; otherwise, the compiler emits error CS1674. The strict exception to this rule is for ref struct types. Because ref struct types could not implement interfaces prior to C# 13, they support synchronous pattern-based disposal by exposing a public, parameterless void Dispose() method.

Syntax Variations

A using statement can either declare a new variable scoped to the block or accept an existing, previously declared variable.

// Declaring a new variable
using (ResourceType resource = new ResourceType())
{
    // Operations on resource
}

// Accepting an existing variable
ResourceType existingResource = new ResourceType();
using (existingResource)
{
    // Operations on existingResource
}

Compiler Transformation

At compile time, the C# compiler translates the using statement into a try-finally block enclosed within an outer block. The outer block ensures the resource variable does not leak into the surrounding scope. This structural lowering guarantees that the Dispose method is executed even if an unhandled exception is thrown or a control-leaving statement (like return or break) is encountered.

The exact lowering depends on the type of the resource being disposed.

Reference Type Lowering: For reference types, the compiler inserts a null check and casts the object to IDisposable before invoking Dispose().

{
    ResourceType resource = new ResourceType();
    try
    {
        // Operations on resource
    }
    finally
    {
        if (resource != null)
        {
            ((IDisposable)resource).Dispose();
        }
    }
}

Non-Nullable Value Type Lowering: For non-nullable value types (structs), the compiler omits the null check, as the type cannot be null. Conceptually, the compiler casts the instance to IDisposable before invoking Dispose(). This ensures that explicit interface implementations of IDisposable.Dispose are correctly resolved. To prevent boxing allocations during this cast, the compiler emits a constrained. prefix at the Intermediate Language (IL) level before the virtual method call.

{
    ValueResourceType resource = new ValueResourceType();
    try
    {
        // Operations on resource
    }
    finally
    {
        ((IDisposable)resource).Dispose();
    }
}

Nullable Value Type Lowering: For nullable value types (Nullable<T> or T?), the compiler generates a null check using the HasValue property. It then extracts the underlying value using the GetValueOrDefault() method before casting to IDisposable and invoking Dispose(). The compiler intentionally uses GetValueOrDefault() rather than the .Value property to bypass the redundant InvalidOperationException check that .Value performs internally.

{
    ValueResourceType? resource = new ValueResourceType();
    try
    {
        // Operations on resource
    }
    finally
    {
        if (resource.HasValue)
        {
            ((IDisposable)resource.GetValueOrDefault()).Dispose();
        }
    }
}

Pattern-Based Lowering (ref struct only): For ref struct types utilizing pattern-based disposal, the compiler directly invokes the Dispose() method without casting to IDisposable. This is necessary because ref struct instances cannot be boxed or cast to interface types.

{
    RefStructDisposableType resource = new RefStructDisposableType();
    try
    {
        // Operations on resource
    }
    finally
    {
        resource.Dispose();
    }
}

Scope and Mutability

When a variable is declared directly within the using statement, it is scoped exclusively to the block and is treated as read-only. Attempting to reassign the variable inside the using block results in a compiler error (CS1656).

Multiple variables of the exact same type can be declared within a single using statement by separating them with commas. The compiler generates nested try-finally blocks to ensure all instances are disposed in the reverse order of their declaration.

using (ResourceType res1 = new ResourceType(), res2 = new ResourceType())
{
    // res1 and res2 are read-only in this scope
}

using Declarations (C# 8.0+)

C# 8.0 introduced the using declaration, which eliminates the need for block braces. The lifetime of the resource is bound to the enclosing lexical scope (typically the end of the method or the nearest set of curly braces). The compiler implicitly generates the try-finally block at the end of this scope.

void Process()
{
    using ResourceType resource = new ResourceType();
    
    // Operations on resource
        
} // resource.Dispose() is called implicitly at the end of the method scope

Asynchronous Disposal (C# 8.0+)

For asynchronous disposal, the await using statement is utilized. This translates into a try-finally block where the finally clause awaits the DisposeAsync method, allowing for non-blocking cleanup.

Unlike synchronous disposal, there is absolutely no pattern-based fallback for await using. The target type strictly must be implicitly convertible to the System.IAsyncDisposable interface. If the type lacks this conversion, the compiler emits error CS8410.

await using (AsyncResourceType resource = new AsyncResourceType())
{
    // Operations on resource
}

Like synchronous using statements, asynchronous disposal also supports the brace-less declaration syntax (await using AsyncResourceType resource = new AsyncResourceType();), binding the asynchronous disposal to the end of the enclosing scope.

Master C# with Deep Grasping Methodology!

Learn More