C# Tuple

Tuple is a data structure that allows you to store a fixed number of elements of different types. It provides a convenient way to group related values together when you don't want to create a separate class or struct for that purpose.

Tuples in C#

Here are some important points to understand about Tuples in C#:

  1. Flexible Composition

    Tuples are flexible and can hold a combination of different data types. You can include elements of any valid C# type, including primitive types, custom classes, structs, and even other tuples.
  2. Immutable

    Tuples are immutable, which means that once created, their values cannot be changed. However, you can create a new tuple with modified values if needed.
  3. Positional Access

    Tuple elements can be accessed by their position using the dot notation, such as tuple.Item1, tuple.Item2, and so on. The elements are ordered based on the order in which they are declared when creating the tuple.
  4. Named Elements

    Starting from C# 7.0, tuples can also have named elements. You can assign names to the elements when declaring the tuple, making it easier to understand the purpose of each element. Named elements can be accessed using the dot notation or by using the element name.

Let's explore some examples to see how to work with Tuples in C#:

Create a simple tuple without named elements:

var person = Tuple.Create("Smith", 25, "London");

In this example, we created a tuple with three elements: a string representing the person's name, an integer representing their age, and a string representing their city.

To access the tuple elements, you can use the positional notation:

string name = person.Item1; // Accessing the first element int age = person.Item2; // Accessing the second element string city = person.Item3; // Accessing the third element

You can also create a tuple with named elements:

var person = (Name: "Smith", Age: 25, City: "London");

In this example, we assigned names to each element of the tuple. Now, you can access the elements using their names:

string name = person.Name; // Accessing the element by name int age = person.Age; // Accessing the element by name string city = person.City; // Accessing the element by name

Tuples are commonly used when you need to return multiple values from a method or when you want to group related values together.

public (string, int) GetPersonDetails() { // Retrieving person details from some data source string name = "Smith"; int age = 25; return (name, age); } // Usage var personDetails = GetPersonDetails(); string name = personDetails.Item1; int age = personDetails.Item2;

Starting from C# 7.0, you can also use tuple deconstruction to directly assign tuple elements to separate variables:

var (name, age) = GetPersonDetails(); // Deconstructing the tuple

In this case, the name and age variables will be assigned the corresponding values from the tuple.


Tuples provide a concise and efficient way to work with a fixed number of related values. They are especially useful in scenarios where you need a lightweight structure to hold temporary or small sets of data. However, if you have a more complex data structure with behavior and additional functionality, it is recommended to create a custom class or struct instead.