Using Tuples With .Net 4.0

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.
  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 that 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
  1. private Tuple<stringstring> GetFandLNames(string name)  
  2. {  
  3.     Tuple<stringstring> flNames = null;  
  4.     string[] names = name.Split(',');  
  5.     flNames = Tuple.Create<stringstring>(names[0], names[1]);  
  6.     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.
  1. private Tuple<DateTime, int> GetDOBAge()  
  2. {  
  3.     Tuple<DateTime, int> flNames = null;  
  4.     flNames = Tuple.Create<DateTime, int>(new DateTime(1973,5,22),30);  
  5.     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
  1. private Tuple<Dictionary<int,string>, Dictionary<int,string>> GetEmployeeDetails()  
  2. {  
  3.     Dictionary<intstring> emp = new Dictionary<intstring>();  
  4.     emp.Add(1, "Jaish");  
  5.     emp.Add(2, "Ramji");  
  6.     emp.Add(3, "Vulise");  
  7.     Dictionary<intstring> dept = new Dictionary<intstring>();  
  8.     dept.Add(1, "Dev");  
  9.     dept.Add(2, "Sales");  
  10.     dept.Add(3, "Test");  
  11.     Tuple<Dictionary<intstring>, Dictionary<intstring>> empDetails = new Tuple<Dictionary<intstring>, Dictionary<intstring>>(emp, dept);  
  12.     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.
  1. Tuple<Dictionary<intstring>, Dictionary<intstring>> empDetails = GetEmployeeDetails();  
  2. foreach (KeyValuePair<intstring> keyValue in empDetails.Item1)  
  3. {  
  4.     MessageBox.Show("ID :" + keyValue.Key + Environment.NewLine + "Name :" + keyValue.Value);  
  5. }  
  6. foreach (KeyValuePair<intstring> keyValue in empDetails.Item2)  
  7. {  
  8.     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.
  1. Tuple<intintintintintintint, Tuple<intint>> tup = new Tuple<intintintintintintint, Tuple<intint>>(1, 2, 3, 4, 5, 6, 7, new Tuple<intint>(8, 9)); 


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