Using Tuples With .Net 4.0

Tuples are not new to software engineering. But ofcource it's new to C#. C# has introduced as a Static programming language where tuples were applicable to dynamic programming languages. What's this Static and Dynamic programming languages. There are dynamic and static programming languages. In a dynamic language, such as Perl or LISP, a developer can create variables without specifying their type. This creates more flexible programs and can simplify prototyping and some object-oriented coding. In a static programming language, such as C or C#, a developer must declare the type of each variable before the code is compiled, making the coding less flexible, but also less error-prone. But in static programming scenario too we have scenarios where tuples can reduce the effort and avoid unwanted lines of code. The latest functional programming language from Microsoft, F# also supports tuples in a far better syntax. Let me explain the tuples world in a C# 4.0 scenario. I hope you already downloaded the attached solution.

The main purpose of tuples introduction in .NET4.0 are based on below needs which were not available till .NET 3.5 and now can be handled with tuples.
  1. Developers using used KeyValuePair{TKey,TValue} just to hold a pair of values together. i.e. only 2 dependent values, but using a type which is meant to store more number of items
  2. Anonymous types cannot be passed out of the method
  3. Need to pass multiple out references to a method, if we needed multiple values from a method. Otherwise declaring a full class and defining properties to return that type from the method.
Above are the scenarios faced till 4.0. How we can tackle these in 4.0 using tuples? Just go through each method in my uploaded code.

1. Method returning 2 values with tuples

private Tuple<string, string> GetFandLNames(string name)
    Tuple<string, string> flNames = null;
    string[] names = name.Split(',');
    flNames = Tuple.Create<string, string>(names[0], names[1]);
    return flNames;

As you can see we are not using any out parameters.  Tuples can be created 2 ways i.e. either using new key word just like creating any object or using static method of Create. Here I used Create. You also need to mention the types exists in side tuple as I mentioned 2 string types which carries first name and last name. Then the method returns the tuple which carries the required first name and last name. Now how we can retrieve the values from tuple? It's using properties. If you have 2 items inside a tuple, you will have 2 properties name "Item1" and "Item2" like below screen shot.


2. Method returning 2 values of different types using tuples

Here explaining tuples which carrying 2 different types rather than same data type. Below is the method which is returning tuple of 2 different typed i.e. Date and int.

private Tuple<DateTime, int> GetDOBAge()
    Tuple<DateTime, int> flNames = null;
    flNames = Tuple.Create<DateTime, int>(new DateTime(1973,5,22),30);
    return flNames;

Values are retrieving same manner as like above. But this time the properties Item1 and Item2 are of different data types.


3. Method returning custom information using Dictionary

private Tuple<Dictionary<int,string>, Dictionary<int,string>> GetEmployeeDetails()
    Dictionary<int, string> emp = new Dictionary<int, string>();
    emp.Add(1, "Jaish");
    emp.Add(2, "Ramji");
    emp.Add(3, "Vulise");
    Dictionary<int, string> dept = new Dictionary<int, string>();
    dept.Add(1, "Dev");
    dept.Add(2, "Sales");
    dept.Add(3, "Test");
    Tuple<Dictionary<int, string>, Dictionary<int, string>> empDetails = new Tuple<Dictionary<int, string>, Dictionary<int, string>>(emp, dept);
    return empDetails;

Above method contains employee and department details. It returns all those details as a single tuple. This tuple contains 2 dictionary types. More over for you people I made this tuple creation using new key word, just for a change. Below explaining the code to iterate through each items in this case.

Tuple<Dictionary<int, string>, Dictionary<int, string>> empDetails = GetEmployeeDetails();
foreach (KeyValuePair<int, string> keyValue in empDetails.Item1)
    MessageBox.Show("ID :" + keyValue.Key + Environment.NewLine + "Name :" + keyValue.Value);
foreach (KeyValuePair<int, string> keyValue in empDetails.Item2)
    MessageBox.Show("ID :" + keyValue.Key + Environment.NewLine + "Dept :" + keyValue.Value);

This time Item1 and Item2 contains more information in the form of Dictionary.


4. How many items can keep in side Tuples

When you check the Tuple, you can see only 8 items are supporting using overriding like below screen shot.


Then how about more numbers? If we need more than 8 items to be kept inside a tuple, we need to care about the last parameter in above screen shot which saying "TRest". We will replace this RTest with another tuple which again can carry 8 items so on. Below is a simple example which is storing 9 numbers in a tuple by replacing the 8th parameter with another new tule.

Tuple<int, int, int, int, int, int, int, Tuple<int, int>> tup = new Tuple<int, int, int, int, int, int, int, Tuple<int, int>>(1, 2, 3, 4, 5, 6, 7, new Tuple<int, int>(8, 9));


The .NET Framework 4 provides the System.Tuple class for creating tuple objects that contain structured data. It also provides generic tuple classes to support tuples that have from one to eight components (that is, singletons through octuples). To support tuple objects that have nine or more components, there is a generic tuple class with seven type parameters and an eighth parameter of any tuple type.