How to iterate over a C# tuple?

A tuple in C# is a data structure that holds multiple values of different types. Since tuples have a fixed structure, you cannot iterate over them using traditional loops like arrays or collections. Instead, you access tuple elements individually using their Item properties or through deconstruction.

Syntax

To create a tuple and access its elements −

// Creating a tuple
Tuple<int, string> tuple = new Tuple<int, string>(100, "Tom");

// Accessing individual elements
tuple.Item1  // first element
tuple.Item2  // second element

For modern C# (7.0+), you can use tuple literals −

var tuple = (100, "Tom");
// Access with Item1, Item2 or named fields

Accessing Tuple Elements Individually

The most straightforward way to work with tuple elements is to access them individually using their Item properties −

using System;

class Program {
   static void Main(string[] args) {
      Tuple<int, string> tuple = new Tuple<int, string>(100, "Tom");

      if (tuple.Item1 == 100) {
         Console.WriteLine("First element: " + tuple.Item1);
      }
      if (tuple.Item2 == "Tom") {
         Console.WriteLine("Second element: " + tuple.Item2);
      }

      // Display entire tuple
      Console.WriteLine("Complete tuple: " + tuple);
   }
}

The output of the above code is −

First element: 100
Second element: Tom
Complete tuple: (100, Tom)

Using Tuple Deconstruction (C# 7.0+)

With modern C#, you can deconstruct a tuple into separate variables, making it easier to work with individual elements −

using System;

class Program {
   static void Main(string[] args) {
      var tuple = (Id: 100, Name: "Tom", Age: 25);

      // Deconstruct tuple into separate variables
      var (id, name, age) = tuple;

      Console.WriteLine($"ID: {id}");
      Console.WriteLine($"Name: {name}");
      Console.WriteLine($"Age: {age}");

      // Alternative: partial deconstruction
      var (userId, userName, _) = tuple; // _ discards the age
      Console.WriteLine($"User: {userName} (ID: {userId})");
   }
}

The output of the above code is −

ID: 100
Name: Tom
Age: 25
User: Tom (ID: 100)

Processing Multiple Tuples

When working with collections of tuples, you can iterate over the collection and access each tuple's elements −

using System;
using System.Collections.Generic;

class Program {
   static void Main(string[] args) {
      var students = new List<(int Id, string Name, int Grade)> {
         (1, "Alice", 85),
         (2, "Bob", 92),
         (3, "Charlie", 78)
      };

      Console.WriteLine("Student Records:");
      foreach (var student in students) {
         Console.WriteLine($"ID: {student.Id}, Name: {student.Name}, Grade: {student.Grade}");
      }

      // Using deconstruction in foreach
      Console.WriteLine("\nUsing deconstruction:");
      foreach (var (id, name, grade) in students) {
         Console.WriteLine($"{name} (ID: {id}) scored {grade}");
      }
   }
}

The output of the above code is −

Student Records:
ID: 1, Name: Alice, Grade: 85
ID: 2, Name: Bob, Grade: 92
ID: 3, Name: Charlie, Grade: 78

Using deconstruction:
Alice (ID: 1) scored 85
Bob (ID: 2) scored 92
Charlie (ID: 3) scored 78

Comparison of Tuple Access Methods

Conclusion

Since tuples have a fixed structure, you cannot iterate over their elements using traditional loops. Instead, access tuple elements individually using Item properties, named fields, or deconstruction. For collections of tuples, iterate over the collection and process each tuple's elements as needed.