C# 7: Tuples

Dawno nie było nic .NETowego. Pora więc to nadrobić informacjami o tym co znajdziemy w nowej wersji C# – wersji 7. Większość rzeczy można już przetestować w Visual Studio 15 preview. Ale jak to z tego typu oprogramowaniem. Lepiej na wirtualce albo na kompie który ma być zaraz zaorany :)

Na pierwszy ogień chciałbym poruszyć Tuples. Nie te, które już są Tuple<T1, T1…> a nowe, które są dużo fajniejsze i zwą się ValueTuple :) Przynajmniej przy Preview 5, by z nich skorzystać trzeba było zainstalować nuget package System.ValueTuple w pre-release mode.

Kiedyś tuple, tworzyliśmy w następujący sposób:

var oldWay  = Tuple.Create("Jakub", 34);

Co dawało nam dostęp do elementów poprzez Item1 i Item2. Po zainstalowaniu paczki System.ValueTuple, to samo, możemy zapisać tak:

var newWay  = ("Jakub", 34);

Ale, tak jak za pierwszym razem, tak i za drugim, nie wiemy co to jest "Jakub" i co to jest to 34. Musimy zawsze wracać do jakiejś dokumentacji czy też implementacji danej metody by się dowiedzieć o co chodzi. By uniknąć takich problemów możemy wartością nadać nazwę:

var newWayNamed = (name: "Jakub", age: 34);

Teraz już nie tylko możemy odwołać się poprzez Item1 czy Item2 ale też poprzez name i age. Do tego funkcje mogą zwracać nowe nowe tuples:

public (int, int) SomeFunction() {}
public (string name, int age) GetInfo(Guid id) {}

za pomocą:

return (10, 10);
return (name: personName, age: personAge);

Na razie to tylko takie… ła, ok, i? nazywamy i co, no, to, że teraz też możemy to robić. Tuple stają się bardziej przyjazne i przyjemne i nie trzeba wykorzystywać Tuple.Create co było dość męczące. No i w końcu jest możliwość obejścia Item1, Item2, Item3… Item10…

Dodatkowo w C# 7, będzie możliwość przypisania istniejącego tuple czy też obiektu pod zmienne lokalne. Dla przykładu powyższy kod możemy rozbić na zmienne name i age w następujący sposób:

(var name, var age) = newWayNamed ;
var (name, age) = newWayNamed ;

string name; int age;
(name, age) = newWayNamed ;

W Elixir taką opcję nazwalibyśmy pattern matching, tutaj nazywa się to deconstructing assignment :) Ta opcja już jest fajna i ciekawa, w szczególności iż napisałem, że możemy ją stosować do obiektów. A to znaczy, że każdy obiekt który będzie implementował metodę:

public void Deconstruct(out T1 x1…) {}

Czy też extension method:

public static void Deconstruct(this T p, out T1 x1 …)

Będzie mógł ulec dekonstrukcji na zmienne. Na przykład:

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public Person(string name, int age)
    {
        this.Name = name;
        this.Age = age;
    }

    public void Deconstruct(out string name, out int age)
    {
        age = this.Age ;
        name = this.Name;
    }
}

// or

public static class DeconstructTest
{
    public static void Deconstruct(this Person p, out string name, out int age)
    {
        name = p.Name;
        age = p.Age;
    }
}

// then

var p = new Person("Jakub", 34);
var (name, age) = p;

To tyle jeżeli chodzi o tuples. Jak dla mnie jest to krok do przodu i w końcu tuples zaczynają się do czegoś przydawać. Tak naprawdę już samo nazwanie poszczególnych elementów dużo daje. Cała reszta to miły lukier składniowy, który nie powiem, dużo daje :)