Tuples are a relatively recent addition to the C# programming language. They were introduced in C# 7.0 as a way to represent a grouping of values without the need to define a custom class or struct. In this blog post, we will explore what tuples are, how they work in C#, and some common use cases for them.

What are Tuples?

In C#, a tuple is a data structure that groups together a set of related values. Tuples are similar to arrays or lists, but they are immutable, which means that once a tuple is created, its values cannot be changed. Tuples can be created using the Tuple class or using tuple literals, which were introduced in C# 7.0.

Tuple Literals

Tuple literals are a shorthand way to create tuples in C#. They are created using the following syntax:

(var1, var2, var3, …)

For example, the following code creates a tuple that contains two integers and a string:

var myTuple = (42, 13, "Hello, World!");

Tuple literals are often used as a return value from a method or as a way to pass multiple values to a method.

Tuple Types

C# supports tuples of different sizes, ranging from one to eight elements. Here are some examples of tuples with different sizes:

Tuple types are defined using the following syntax:

Tuple<T1> // Tuple with one element 
Tuple<T1, T2> // Tuple with two elements 
Tuple<T1, T2, T3> // Tuple with three elements 
Tuple<T1, T2, T3, T4> // Tuple with four elements
Tuple<T1, T2, T3, T4, T5> // Tuple with five elements 
Tuple<T1, T2, T3, T4, T5, T6> // Tuple with six elements 
Tuple<T1, T2, T3, T4, T5, T6, T7> // Tuple with seven elements
Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> // Tuple with eight elements

Tuple types can have up to eight elements. If you need more elements, you can nest tuples inside other tuples.

For example, the following code defines a tuple type that contains an integer and a string:

Tuple<int, string> myTuple = Tuple.Create(42, "Hello, World!");

Tuple Deconstruction

Tuple deconstruction is a feature that was introduced in C# 7.0. It allows you to assign the values of a tuple to individual variables in a single statement. For example, consider the following code:

var myTuple = (42, "Hello, World!");
var (myInt, myString) = myTuple;

In this code, the values of the tuple myTuple are assigned to the variables myInt and myString using tuple deconstruction. Tuple deconstruction can be a convenient way to work with tuples because it allows you to extract the individual values of a tuple without needing to access them by index.

Tuple Usage

Tuples are useful in a variety of situations. One common scenario where tuples are useful is when you want to return multiple values from a method. In C# 6.0 and earlier versions, you would typically return a custom class or a struct with properties to hold the return values. However, with tuples, you can return multiple values without creating a custom class or struct.

Here's an example of a method that returns a tuple:

public static (int, string) GetPersonInfo(int id) 
  // Retrieve person information from database 
  int age = 30; string name = "John Doe"; 
  return (age, name); 

In this example, the GetPersonInfo method returns a tuple with two elements, an int and a string, representing the person's age and name, respectively. The return statement creates a tuple with the two values and returns it.

Complete Console Application Example of C# Tuple

using System;

namespace TupleInCsharp
    public class Program
        public static void Main()
            //create simple tuple
            var user = Tuple.Create(1,  "India");
            var Id = user.Item1; // 1
            var name = user.Item2; // India

            Console.WriteLine(Id + " " + name);

            //Nested Tuples
            var numbers = Tuple.Create(1, Tuple.Create(2, 3, 4, 5, 6));
            Console.WriteLine("{0}", numbers.Item1);
            Console.WriteLine("{0}", numbers.Item2.Item1);
            Console.WriteLine("{0}", numbers.Item2.Item4);


1 India


Tuple Methods

The Tuple class provides several methods that you can use to work with tuples. Some of the most commonly used methods are:

  • Create<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>: Creates a new tuple with the specified values.
  • Item1, Item2, Item3, …: Gets the value of the specified element of the tuple.
  • Equals(object obj): Determines whether the specified object is equal to the current tuple.
  • GetHashCode(): Returns the hash code for the current tuple.
  • ToString(): Returns a string that represents the current tuple.

That's it.

You may also like to read:

Create or initialize List Tuple in C#

Return Multiple values in C# (Various ways)

Add values in C# array (Multiple ways)

Tic Tac Toe Game in C# Console application

Iterate Over Dictionary in C# (Various ways)

Compare JSON using C# and Get difference