In the section named Tuples: implementation in C#, we saw how to declare and use tuples using the Tuple class, and, also, some of the drawbacks linked to that early version or these objects.

Now, in C# 7, tuples reach a new dimension. You no longer have to use the Tuple class to declare tuples, and thanks to pattern matching, the compiler is perfectly comfortable with declarations that include a tuple syntax next to a var definition or use a tuple as the return type of a method (allowing us to return more than a value, without requiring out parameters):

(int n, string s) = ( 4, "data" );

The previous declaration is now understood by the compiler, as the next capture shows:

That makes the use of the Tuple class unnecessary and also it makes much natural to work with these types. Besides, we had to use the members Item1, Item2, and so on to access the values of the tuple. Now we can give descriptive names to each member of the tuple to clarify its purpose (such as n and s in this sample).

Another advantage is that you can return a tuple in a function. Let's follow an adapted version of the official demo that PM Mads Torgersen usually presents to explain this feature.

Imagine that we want to know how many items there are inside the initial declaration of binNumbers and also perform a sum of all its members, in the same function. We could write a method like this:

static (int sum, int count) ProcessArray(List<int> numbers)
{
  var result = (sum:0 , count:0);
  numbers.ForEach(n =>
  {
    result.count++;
    result.sum += n;
  });
  return result;
}

Now, invoke the method and present the results in this way:

var res = ProcessArray(binNumbers.ToList());
Console.WriteLine($"Count: {res.count}");
Console.WriteLine($"Sum: {res.sum}");
Console.Read();

We obtain the expected results. But let's go through the code to view the details of the implementation.

First, the return value of the function is a tuple and its members, named accordingly, which makes the calling code more readable. Also, the internal result variable is defined and initialized with the tuple syntax: a list of comma-separated values, optionally prefixed with a name for clarity.

The return value is then assigned to the res variable, which can use the named parameters to output them in the console using string interpolation.

Decomposition is a characteristic that allows us to deconstruct or decompose an object into its parts, or some of its parts.

For instance, in the declaration of the res variable, we could even avoid the use of res by declaring the named members of the tuple, to obtain exactly the same results:

var (count, sum) = ProcessArray(binNumbers.ToList());

As you can see, we can have access to the required returning values, but there's no need to hold them in a named variable; thus, we say that the resulting value has been "decomposed" into its forming parts.

Of course, in this case, we're taking advantage that the type to deconstruct is a tuple already. What about other objects? You can deconstruct any object as long as it has a Deconstruct method defined or you create an extension method with that name.

Let's say we want to be able to decompose a DateTime value. Of course, there's no Deconstruct method defined inside the DateTime object, but we can create one pretty easily:

static void Deconstruct(this DateTime dt, out int hour,
  out int minute, out int second)
{
  hour = dt.Hour;
  minute = dt.Minute;
  second = dt.Second;
}

Once we have that definition accessible, we could "extract" those values from the current time with a sentence like this:

var (hour, minute, second) = DateTime.Now;
Console.WriteLine($"Hour: {hour} - Minute: {minute} - Second: {second}");

And we would get the output shown in the following capture, which also shows the previous calculation on the number or items in the array and its sum:

JavaScript programmers are used to passing functions as parameters and returning functions as a return value. That's not available in C#, except for the functionality available through lambda expressions that we saw in the previous chapter.

Local functions are not that, but they allow us to declare a function that is local to another closing function, with the ability to access the variables defined in the upper function. Therefore, they are local to the function in which they are declared.

Go back to our demo of ProcessArray and imagine you want to separate the code inside the ForEach loop aside in another function, but you want to modify the values directly (without the out references).

You could rewrite the process with an inside function of this kind with the following syntax:

static (int sum, int count) ProcessArrayWithLocal(List<int> numbers)
{
  var result = (s: 0, c: 0);
  foreach (var item in numbers)
  {
    ProcessItem(item, 1);
  }
  return result;
  void ProcessItem(int s, int c) { result.s+= s; result.c += c; };
}

This time, we go through the collection using a ForEach loop and, inside the loop, we call the local function ProcessItem, which has access to the result members.

In which cases do these inside functions make sense? One case would be when a helper method is only going to be used inside a single function, like in this case.

Finally, let's learn a bit about these feature, which is only partially available, since they plan to extend it along the quick-path-release cadence of the language they announced in Connect(); 2016 event.

The idea is that in the same way you can pass values by reference, now you can return reference values and even store values in reference variables.

The Mads Torgersen code mentioned previously includes the following (self-explaining) code, to see how we would declare such a function a how we could use it:

public ref int Find(int number, int[] numbers)
{
  for (int i = 0; i < numbers.Length; i++)
  {
    if (numbers[i] == number) 
    {
      return ref numbers[i]; // return the storage location, not the value
    }
  }
  throw new IndexOutOfRangeException($"{nameof(number)} not found");
}

int[] array = { 1, 15, -39, 0, 7, 14, -12 };
ref int place = ref Find(7, array); // aliases 7's place in the array
place = 9; // replaces 7 with 9 in the array
WriteLine(array[4]); // prints 9

In the code, the function is marked with ref right before declaring the return type (int). Later, after declaring an array of numbers, the function is called with a 7 as the first parameter.

The value 7 occupies the fifth position in the array, so its order number is 4. But since the returned value is stored as ref, a subsequent assignment of 9 changes that value inside the array to 9. That's why the final sentence prints 9.

In all, perhaps the changes included in this last version of the language are not as meaningful as there were those in versions 2, 3, or 4 of the language, but even so, they facilitate the programmer's tasks in some situations.