> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C# 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. ```csharp theme={"dark"} // 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()`. ```csharp theme={"dark"} { 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. ```csharp theme={"dark"} { ValueResourceType resource = new ValueResourceType(); try { // Operations on resource } finally { ((IDisposable)resource).Dispose(); } } ``` **Nullable Value Type Lowering:** For nullable value types (`Nullable` 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. ```csharp theme={"dark"} { 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. ```csharp theme={"dark"} { 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. ```csharp theme={"dark"} 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. ```csharp theme={"dark"} 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. ```csharp theme={"dark"} 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.

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More