.NET

Tuples in .NET world and C# 7.0 improvements

Back in the day when I was a young developer, I was using output parameters. Then I figured out it is somewhat complicated to test functions with output parameters, and that their use is clunky at best. Also, out parameters don’t work with async function, because of CLR limitations. In general, I liked them less and less. So, I started writing DTOs – Data Transfer Objects, to avoid this kind of situation and keep my design as clean as possible. Then I started writing a lot of DTOs, and I mean a lot of DTOs. In fact, they were affecting cleanness of my code now. Especially when I had to group values which are really not having much in common. This was happening usually on DAL modules. All of this seemed like a lot of overhead just to pass some values around. And then, I have discovered Tuples.

Definitions

Tuples come from set theory, where the tuple is defined as a finite ordered list of elements. Unlike ordered lists, the same element can appear more than once inside the tuple. They can pretty much look like this – (a, b, a). Still, the order is important. Some other definitions say that tuples are ordered multiset. To sum it up in few points:

  • Tuple is used to describe some form of the finite sequence of elements
  • Element can appear more than once in the tuple
  • The order of the elements in the tuple is important

In computer science, the form of the tuples and the way that are used variates from one programming language to another. Tuple in Pyton is an immutable list, in Scala it is used to mix different types, and in functional languages tuples are used for pattern matching. It is debatable, but JavaScript object can be considered a tuple.

Tuples in .Net

In the .NET world Tuple is a data structure with a specific number and sequence of elements, first introduced in .NET 4.0. It is important to notice that Tuple is a structure, ie. value type and that it’s fields are public and mutable. Here is an example:

var person = new Tuple<string, string, int>(
                           "Nikola", "Rubiks Code", 30);

Console.WriteLine("{0} has a blog called {1}, and he is {2} years old",
                  person.Item1, person.Item2, person.Item3);

As mentioned before, Tuples can be used to return multiple values from the function, without using out or ref parameters, but that is not their only use. They can be used to pass multiple values trough the one function parameter. Also, since they have value equality, Tuples can be used if you need a dictionary with multiple keys or list with multiple values on each position.
Still, before C# 7.0, using Tuples was not so natural for many software craftsmen. They seem a bit stodgy and you always had to remember which value has been assigned to which item of the tuple. A code was cleaner, in a sense that there were no more DTOs as before, but tuples definitely added a lot of mess. Also, they were not applicable to the public API, for the same reasons.

Tuple Types and Tuple Literals in C# 7.0

In order to make Tuples more friendly, guys at Microsoft introduced some new features in C# 7.0. These allow us to define function return values in more understandable manner. For example, our function from before can now be presented like this:

private (string, string, int) GetNameBlogAndAge()
{
     return ('Nikola Zivkovic', 'RubiksCode', 30);
}

We can see it is a little bit easier to understand what is going on now, but still, if you want to access those values, you will have to do something like this:


var nameBlogAge = GetNameBlogAndAge();
Console.WriteLine("Name is: {0}", nameBlogAge.Item1);

So, we are again accessing tuple element using confusing “Item1” name. But this is also upgrated in new version of C#. Now, we can name each field in the Tuple like this:


private static (string name, string blog, int age) GetNameBlogAndAge()
{
     return ('Nikola Zivkovic', 'RubiksCode', 30);
}

Or asigning element names inside litelar itself, like this:

private static (string, string, int) GetNameBlogAndAge()
{
     return (name: 'Nikola', blog: 'RubiksCode', age: 30);
}

So, consuming Tuple can be done in more natural way:

var nameBlogAge = GetNameBlogAndAge();
Console.WriteLine("Name is: {0}", nameBlogAge.name);

The other thing that is also very usefull is that tuples now can be used in deconstructing declaration. This is best shown in example:

(string name, string blog, int age) = GetNameBlogAndAge();
Console.WriteLine("Name is: {0}", name);

This means that you can split tuple into its elements and assign those elements separately to new variables.

Conclusion

Tuples solve a lot of problems that you had with DTOs and output parameters. Also, problems with its usability and naming are upgraded in C# 7.0. Frankly, it reminds me of JSON objects, and also some of the Typescript features. Remember how Typescript was presented as JavaScript for C# developers? It seems to me that now this change is pushing C# towards something that will remind us of JavaScript. Who knows, maybe these two currents will find middle ground in one unified solution.

Read more posts from the author at Rubik’s Code.

Creative Commons License
This work is licensed under a Creative Commons Attribution 4.0 International License.

2 thoughts on “Tuples in .NET world and C# 7.0 improvements”

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s