> ## 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# Tuple Deconstruction Tuple deconstruction is a syntactic feature in C# that extracts the individual elements of a tuple and assigns them to discrete variables in a single operation. It allows developers to unpack the fields of a `System.ValueTuple` directly into local scope without needing to access the underlying `.Item1`, `.Item2`, or custom-named fields sequentially. ## Syntax Variations The C# compiler supports multiple syntactical approaches for deconstructing a tuple, depending on variable scope and type inference requirements. **1. Explicitly Typed Declaration** You can declare the type of each variable explicitly within the deconstruction parenthesis. ```csharp theme={"dark"} (string name, int age, bool isActive) = ("Alice", 30, true); ``` **2. Implicitly Typed Declaration (`var`)** Type inference can be applied either to the entire deconstruction expression or to individual elements. ```csharp theme={"dark"} // Global implicit typing (preferred for brevity) var (name, age, isActive) = ("Alice", 30, true); // Individual implicit typing (var name, var age, var isActive) = ("Alice", 30, true); ``` **3. Assignment to Existing Variables** Deconstruction can assign values to variables that have already been declared in the current scope. ```csharp theme={"dark"} string name; int age; bool isActive; // Reassigning existing variables via deconstruction (name, age, isActive) = ("Alice", 30, true); ``` **4. Mixed Declaration and Assignment (C# 10+)** C# 10 introduced the ability to mix the declaration of new variables with the assignment of existing variables within the same deconstruction operation. ```csharp theme={"dark"} string existingName; (existingName, int newAge, var newIsActive) = ("Alice", 30, true); ``` ## Discards in Deconstruction When a tuple contains elements that are not required in the local scope, you can use discards (`_`). A discard is a write-only, unassigned variable that instructs the compiler to ignore the specific tuple element at that ordinal position. This prevents the allocation of unnecessary local variables. ```csharp theme={"dark"} // The integer at Item2 is discarded var (name, _, isActive) = ("Alice", 30, true); ``` Multiple discards can be used in a single deconstruction expression. The compiler resolves them independently. ```csharp theme={"dark"} var (_, _, isActive) = ("Alice", 30, true); ``` ## Compiler Mechanics When you deconstruct a tuple, the C# compiler translates the syntax into direct field assignments from the underlying `System.ValueTuple` struct. For example, this deconstruction: ```csharp theme={"dark"} var (x, y) = GetCoordinates(); // Returns (int, int) ``` Is lowered by the compiler to: ```csharp theme={"dark"} System.ValueTuple tuple = GetCoordinates(); int x = tuple.Item1; int y = tuple.Item2; ``` Unlike user-defined classes or records, which require an explicit `Deconstruct(out T1 var1, out T2 var2)` method to enable deconstruction syntax, tuples are natively understood by the compiler. The compiler maps the positional elements of the tuple directly to the variables provided in the deconstruction expression based strictly on their ordinal index.

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