Tuple C#: Named Tuple, Mengembalikan Banyak Nilai, Dekonstruksi

Tuple membungkus sejumlah kecil nilai yang jumlahnya tetap menjadi satu nilai, tanpa perlu mendeklarasikan class untuknya. ("Ana", 31) adalah tuple berisi sebuah string dan sebuah int. Tuple adalah cara yang lazim untuk mengembalikan dua atau tiga hal dari sebuah method, dan untuk menyimpan pasangan nilai berumur pendek di dalam method.

Membuat tuple

Tipenya juga ditulis dengan tanda kurung: (string, int) adalah tipe tuple yang elemen pertamanya string dan elemen keduanya int.

using System;

class Program
{
    static void Main()
    {
        var pair = ("Ana", 31);                     // type: (string, int)
        Console.WriteLine(pair.Item1 + " is " + pair.Item2);

        var point = (3, 4);                         // (int, int)
        Console.WriteLine(point);                   // ToString shows the values

        var order = ("A-1001", 3, 59.90m);          // any number of elements
        Console.WriteLine(order.Item3 * order.Item2);

        pair.Item2 = 32;                            // elements are mutable fields
        Console.WriteLine(pair);
    }
}

Output:

Ana is 31
(3, 4)
179.70
(Ana, 32)

Tanpa nama, elemennya adalah Item1, Item2, Item3 dan seterusnya. Tuple ini adalah struct System.ValueTuple, jadi menyimpannya ke variabel lain akan menyalin nilainya, dan mengubah salinannya tidak memengaruhi yang asli.

Elemen bernama

Item1 tidak menjelaskan apa isi nilainya. Beri nama pada elemennya, baik di tipe maupun di literal:

using System;

class Program
{
    static void Main()
    {
        (string Name, int Age) person = ("Ana", 31);    // names in the type
        Console.WriteLine(person.Name + ", " + person.Age);

        var product = (Title: "Desk lamp", Price: 24.99m); // names in the literal
        Console.WriteLine(product.Title + " costs " + product.Price);

        Console.WriteLine(person.Item1);                 // still available

        (string First, int Years) renamed = person;      // names do not have to match
        Console.WriteLine(renamed.First);
    }
}

Output:

Ana, 31
Desk lamp costs 24.99
Ana
Ana

Nama adalah kemudahan saat kompilasi. Saat program berjalan, kedua tuple di atas hanyalah nilai ValueTuple<string, int> biasa, karena itulah menyimpan person ke tuple dengan nama berbeda tetap bisa dikompilasi: yang harus cocok hanya tipe elemen dan urutannya.

C# 7.1 dan sesudahnya juga menyimpulkan nama dari variabel di dalam literal, jadi var t = (name, age); memberimu t.name dan t.age tanpa harus menulisnya dua kali. Di C# 7.0, elemen-elemen itu hanya Item1 dan Item2.

Mengembalikan banyak nilai dari method

Inilah alasan utama tuple ditambahkan ke bahasa ini. Sebelumnya, pilihannya adalah parameter out, class sekali pakai, atau System.Tuple dengan Item1 yang tidak bernama.

using System;

class Program
{
    static (int Min, int Max, double Average) Stats(int[] scores)
    {
        int min = scores[0], max = scores[0], sum = 0;
        foreach (int s in scores)
        {
            if (s < min) min = s;
            if (s > max) max = s;
            sum += s;
        }
        return (min, max, (double)sum / scores.Length);
    }

    static void Main()
    {
        int[] scores = { 72, 95, 60, 88 };

        var stats = Stats(scores);
        Console.WriteLine("Lowest " + stats.Min + ", highest " + stats.Max);
        Console.WriteLine("Average " + stats.Average.ToString("F2"));
    }
}

Output:

Lowest 60, highest 95
Average 78.75

Nama elemen di tipe kembalian menjadi nama yang dilihat pemanggil. Bandingkan dengan method yang sama memakai parameter out:

static void Stats(int[] scores, out int min, out int max, out double average) { ... }

Stats(scores, out int min, out int max, out double avg);

Parameter out tetap menjadi konvensi untuk bentuk TryParse, saat sebuah bool menyatakan berhasil atau tidak dan nilainya dikembalikan bersamanya. Untuk "hitung beberapa hal lalu kembalikan semuanya", tuple lebih enak dibaca. Lihat ref dan out.

Dekonstruksi

Dekonstruksi membongkar tuple menjadi variabel-variabel terpisah dalam satu pernyataan:

using System;

class Program
{
    static (string City, double TempC) Warmest()
    {
        return ("Lima", 24.5);
    }

    static void Main()
    {
        var (city, temp) = Warmest();                 // new variables, types inferred
        Console.WriteLine(city + " " + temp.ToString("F1"));

        (string c, double t) = Warmest();             // explicit types
        Console.WriteLine(c);

        var (_, onlyTemp) = Warmest();                // discard what you do not need
        Console.WriteLine(onlyTemp.ToString("F1"));

        int a = 1, b = 2;
        (a, b) = (b, a);                              // swap without a temp variable
        Console.WriteLine(a + " " + b);
    }
}

Output:

Lima 24.5
Lima
24.5
2 1

Nama variabel di var (city, temp) bebas kamu tentukan; nama itu tidak harus sama dengan nama elemen tuple, karena dekonstruksi bekerja berdasarkan posisi. Swap (a, b) = (b, a) membuat tuple dari nilai lama lebih dulu, baru kemudian mengisinya, jadi tidak ada nilai yang hilang.

Class milikmu sendiri bisa mendukung dekonstruksi dengan mendeklarasikan method Deconstruct yang punya parameter out. Sejak C# 7 dengan .NET Core 2.0 atau sesudahnya, KeyValuePair juga punya method itu, jadi loop dictionary bisa membongkar setiap entri langsung di kepala loop:

class Point
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
    public void Deconstruct(out int x, out int y) { x = X; y = Y; }
}

var (x, y) = new Point(3, 4);

foreach (var (name, score) in scoresByName)   // Dictionary<string, int>
{
    Console.WriteLine($"{name}: {score}");
}

Bentuk foreach (var (a, b) in listOfTuples) yang sama juga berlaku untuk list berisi tuple. Mengambil seluruh tuple sebagai satu variabel loop lalu membaca elemen bernamanya, seperti di bagian berikutnya, juga sama baiknya.

Tuple di list, LINQ, dan dictionary

List berisi named tuple adalah cara ringan untuk menyimpan baris-baris data di dalam method:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var results = new List<(string Name, int Score)>
        {
            ("Ana", 88),
            ("Ben", 72),
            ("Chloe", 95),
        };

        foreach (var r in results.OrderByDescending(r => r.Score))
        {
            Console.WriteLine(r.Name + " " + r.Score);
        }

        var passed = results
            .Where(r => r.Score >= 80)
            .Select(r => (r.Name, Grade: r.Score >= 90 ? "A" : "B"))
            .ToList();
        Console.WriteLine(string.Join(", ", passed));

        // Tuples compare by value, so they work as composite dictionary keys.
        var seats = new Dictionary<(int Row, int Col), string>
        {
            [(1, 4)] = "Ana",
            [(2, 7)] = "Ben",
        };
        Console.WriteLine(seats[(2, 7)]);
        Console.WriteLine(seats.ContainsKey((3, 1)));
    }
}

Output:

Chloe 95
Ana 88
Ben 72
(Ana, B), (Chloe, A)
Ben
False

ValueTuple mengimplementasikan Equals dan GetHashCode elemen demi elemen, jadi (2, 7) yang dibuat di dua tempat berbeda menemukan entri dictionary yang sama. Ini menjadikan tuple key gabungan yang paling sederhana: tanpa class, tanpa fungsi hash yang ditulis manual, tanpa penggabungan string seperti row + ":" + col.

Kesamaan tuple

Equals membandingkan elemen demi elemen dan sudah berfungsi sejak tuple diperkenalkan:

using System;

class Program
{
    static void Main()
    {
        var a = (Name: "Ana", Age: 31);
        var b = (Title: "Ana", Years: 31);   // different names, same values

        Console.WriteLine(a.Equals(b));
        Console.WriteLine(a.Equals(("Ana", 32)));
    }
}

Output:

True
False

C# 7.3 menambahkan == dan != untuk tuple, yang dikompilasi menjadi perbandingan elemen demi elemen yang sama dan juga mengabaikan nama:

if ((order.Status, order.Paid) == ("shipped", true)) { ... }
Console.WriteLine((1, "x") == (1, "x"));   // True

System.Tuple vs ValueTuple

.NET 4 memperkenalkan System.Tuple, sebuah class yang dibuat dengan Tuple.Create. Class ini masih ada di framework dan masih muncul di kode dan API lama, karena itulah pencarian "C# tuple" sering mengarah ke sana.

using System;

class Program
{
    static void Main()
    {
        Tuple<string, int> old = Tuple.Create("Ben", 25);
        Console.WriteLine(old.Item1 + " " + old.Item2);
        // old.Item2 = 26;  // compile error: Item2 is read-only

        var converted = old.ToValueTuple();   // (string, int)
        Console.WriteLine(converted);
    }
}

Output:

Ben 25
(Ben, 25)

ToValueTuple() dan ToTuple() mengonversi di antara keduanya. Utamakan value tuple di kode baru: value tuple tidak mengalokasikan apa pun di heap dan bisa membawa nama.

Kapan memakai class atau record

Tuple paling cocok saat pengelompokannya bersifat lokal dan jelas: method mengembalikan dua angka, query LINQ membawa sepasang nilai ke langkah berikutnya, dictionary butuh key dua bagian. Beralihlah ke tipe bernama saat:

• Bentuk yang sama muncul di beberapa signature method public. (string, string, int) di lima tempat adalah class yang belum ditulis.
• Nilai-nilainya butuh perilaku, validasi, atau lebih dari tiga atau empat elemen.
• Datanya melewati batas seperti serialisasi. Nama tidak ada saat program berjalan, jadi Newtonsoft.Json menulis Item1 dan Item2, dan System.Text.Json menulis {} karena elemen tuple berupa field, yang secara default dilewati.

Record di C# 9 memberimu hampir semua kemudahan tuple dengan nama yang sungguhan. record Score(string Name, int Points); sudah punya value equality, ToString yang mudah dibaca, dan dekonstruksi bawaan. Lihat record.

Kesalahan umum

• Mengira nama tetap ada saat program berjalan. Reflection dan serializer melihat Item1, Item2 (atau tidak melihat apa pun).
• Mengubah salinan. Tuple adalah struct: var t2 = t1; t2.Item1 = 5; tidak mengubah t1.
• Tuple dengan banyak elemen. Lebih dari tiga atau empat, tipe bernama lebih enak dibaca.
• Tertukar urutan dekonstruksi. Dekonstruksi bekerja berdasarkan posisi: dengan tuple (Name, Age), var (age, name) = person; memasukkan nama ke age, dan karena var menyimpulkan tipenya, tidak ada peringatan sama sekali.