Using Tuples With .Net 4.0

Jaish Mathews

Tuples.net tuplesTuples in .Net 4.0Tuples with .Net 4.0

3 Comments

Join the conversation! Your thoughts help the community grow.

Priyanka Kale8y ago
A very well-crafted article. Thanks for sharing great info about Tuples in .NET Framework .
Wes Plybon15y agoedited
Whenever you make a call to Tuple.Create (or any other generic method for that matter) both the C# and VB compilers are able to make an attempt at inferring the generic type parameters. For instance: Tuple.Create<DateTime, int>(new DateTime(1973,5,22),30); Can be equally (and more concisely) written as: Tuple.Create(new DateTime(1973,5,22),30); When it compiles, the IL will look more like the first example, with the type parameters included. But the second is quite a bit more clean. This, however, is only true for generic methods. Constructors of generic types, lack the ability to perform generic type inference. The situation I just explained is actually the reason Tuple.Create even exists. Using Tuple.Create frees you from having to specify the generic type parameters of the constructor and leaves it to the specific implementation of Tuple.Create. Combined with the var keyword your Tuple declarations can get even more concise and no less readable (IMO). Given: 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)); You can re-write to: var tup = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9));
Yuriy16y ago
Thank you for good, short and clear article.

Tuples are not new to software engineering. But of course, it's new to C#. C# has introduced as a Static programming language where tuples were applicable to dynamic programming languages. What are these 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 scenarios to 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 is based on the below needs which were not available till .NET 3.5 and now can be handled with tuples.

Developers using used KeyValuePair{TKey,TValue} just to hold a pair of values together. i.e. only 2 dependent values, but using a type that is meant to store more number of items
Anonymous types cannot be passed out of the method
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 in 2 ways i.e. either using the new keyword just like creating any object or using a static method of Create. Here I used Create. You also need to mention the types that exist in the side tuple as I mentioned 2 string types that carry the 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 the below screenshot.

2. Method returning 2 values of different types using tuples

Here explaining tuples that carrying 2 different types rather than the 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 in the same manner as 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. Moreover, for you people I made this tuple creation using the new keyword, just for a change. Below explaining the code to iterate through each item 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 contain more information in the form of a Dictionary.

4. How many items can keep inside Tuples

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

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 the above screenshot 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));

Summary

.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.