Tuple C#: named tuple, trả về nhiều giá trị, deconstruction

Tuple gói một số lượng nhỏ, cố định các giá trị thành một giá trị duy nhất mà không cần khai báo lớp riêng. ("Ana", 31) là một tuple gồm một string và một int. Tuple là cách viết quen thuộc để trả về hai hoặc ba thứ từ một phương thức và để giữ các cặp giá trị dùng tạm bên trong một phương thức.

Tạo một tuple

Kiểu của tuple cũng được viết bằng dấu ngoặc tròn: (string, int) là một kiểu tuple có phần tử đầu là string và phần tử thứ hai là 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);
    }
}

Đầu ra:

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

Khi không đặt tên, các phần tử là Item1, Item2, Item3 và cứ thế. Các tuple này là struct System.ValueTuple, nên gán một tuple cho biến khác sẽ sao chép các giá trị, và sửa bản sao không ảnh hưởng tới bản gốc.

Đặt tên phần tử

Item1 không nói gì về ý nghĩa của giá trị. Hãy đặt tên cho các phần tử, trong kiểu hoặc trong 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);
    }
}

Đầu ra:

Ana, 31
Desk lamp costs 24.99
Ana
Ana

Tên chỉ là tiện ích lúc biên dịch. Lúc chạy, cả hai tuple ở trên đều là giá trị ValueTuple<string, int> bình thường, vì thế gán person cho một tuple có tên khác vẫn biên dịch được: chỉ cần kiểu và thứ tự các phần tử khớp nhau.

Từ C# 7.1, tên còn được suy ra từ các biến trong literal, nên var t = (name, age); cho bạn t.name và t.age mà không phải viết lại. Trong C# 7.0, các phần tử đó chỉ là Item1 và Item2.

Trả về nhiều giá trị từ một phương thức

Đây là lý do chính tuple được thêm vào ngôn ngữ. Trước đó, các lựa chọn là tham số out, một lớp dùng một lần, hoặc System.Tuple với Item1 vô danh.

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"));
    }
}

Đầu ra:

Lowest 60, highest 95
Average 78.75

Tên phần tử trong kiểu trả về trở thành tên mà nơi gọi nhìn thấy. So sánh với cùng phương thức đó viết bằng tham số 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);

Tham số out vẫn là quy ước cho kiểu TryParse, nơi một bool cho biết thao tác có thành công không và giá trị được trả kèm theo. Còn với kiểu "tính vài thứ rồi trả về", tuple dễ đọc hơn. Xem ref và out.

Deconstruction

Deconstruction tách một tuple thành các biến riêng trong một câu lệnh:

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);
    }
}

Đầu ra:

Lima 24.5
Lima
24.5
2 1

Tên biến trong var (city, temp) là do bạn đặt; chúng không cần trùng với tên phần tử của tuple, vì deconstruction đi theo vị trí. Phép hoán đổi (a, b) = (b, a) dựng một tuple từ các giá trị cũ trước rồi mới gán, nên không giá trị nào bị mất.

Lớp của chính bạn cũng có thể hỗ trợ deconstruction bằng cách khai báo phương thức Deconstruct với các tham số out. Từ C# 7 với .NET Core 2.0 trở lên, KeyValuePair cũng có phương thức này, nên một vòng lặp qua dictionary có thể tách từng mục ngay ở phần đầu vòng lặp:

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}");
}

Cách viết foreach (var (a, b) in listOfTuples) cũng dùng được cho một list tuple. Lấy cả tuple làm một biến lặp rồi đọc các phần tử có tên của nó, như phần tiếp theo, cũng tốt không kém.

Tuple trong list, LINQ và dictionary

Một list các named tuple là cách gọn nhẹ để giữ các hàng dữ liệu bên trong một phương thức:

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)));
    }
}

Đầu ra:

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

ValueTuple cài đặt Equals và GetHashCode theo từng phần tử, nên (2, 7) được tạo ở hai nơi khác nhau vẫn tìm thấy cùng một mục trong dictionary. Điều đó khiến tuple trở thành khóa tổng hợp đơn giản nhất: không cần lớp, không cần tự viết hàm băm, không cần nối chuỗi kiểu row + ":" + col.

So sánh tuple

Equals so sánh theo từng phần tử và đã dùng được từ khi tuple ra đời:

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)));
    }
}

Đầu ra:

True
False

C# 7.3 thêm == và != cho tuple, được biên dịch thành cùng phép so sánh từng phần tử và cũng bỏ qua tên:

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

System.Tuple và ValueTuple

.NET 4 giới thiệu System.Tuple, một lớp được tạo bằng Tuple.Create. Nó vẫn có trong framework và vẫn xuất hiện trong code và API cũ, vì vậy khi tìm "tuple C#" bạn thường gặp nó.

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);
    }
}

Đầu ra:

Ben 25
(Ben, 25)

ToValueTuple() và ToTuple() chuyển đổi qua lại giữa hai loại. Trong code mới hãy ưu tiên value tuple: chúng không cấp phát gì trên heap và có thể mang tên.

Khi nào nên dùng lớp hoặc record

Tuple phù hợp nhất khi nhóm giá trị mang tính cục bộ và dễ hiểu: một phương thức trả về hai con số, một truy vấn LINQ chuyển một cặp sang bước tiếp theo, một dictionary cần khóa gồm hai phần. Hãy chuyển sang một kiểu có tên khi:

• Cùng một dạng xuất hiện trong nhiều chữ ký phương thức public. (string, string, int) ở năm chỗ là một lớp chưa được viết ra.
• Các giá trị cần hành vi, cần kiểm tra hợp lệ, hoặc có nhiều hơn ba bốn phần tử.
• Dữ liệu đi qua một ranh giới như serialization. Tên không tồn tại lúc chạy, nên Newtonsoft.Json ghi ra Item1 và Item2, còn System.Text.Json ghi ra {} vì phần tử của tuple là field, thứ mà nó bỏ qua theo mặc định.

Record của C# 9 cho bạn phần lớn sự tiện lợi của tuple cùng với một cái tên thật. record Score(string Name, int Points); có sẵn so sánh theo giá trị, ToString dễ đọc và deconstruction. Xem record.

Lỗi thường gặp

• Mong tên còn giữ được lúc chạy. Reflection và các serializer chỉ thấy Item1, Item2 (hoặc không thấy gì cả).
• Sửa một bản sao. Tuple là struct: var t2 = t1; t2.Item1 = 5; không làm thay đổi t1.
• Tuple có quá nhiều phần tử. Quá ba hoặc bốn phần tử thì một kiểu có tên sẽ dễ đọc hơn.
• Nhầm thứ tự khi deconstruction. Nó đi theo vị trí: với tuple (Name, Age), var (age, name) = person; đặt tên người vào age, và vì var tự suy ra kiểu nên không có cảnh báo nào.