簡介

元組是 C# 中用於存儲一組固定數量、可能不同類型的值的數據結構。它是值類型（ValueTuple），在內存中分配於棧上（除非作為對象引用使用），因此性能較高。元組的主要用途是：

• 臨時組合數據，而無需創建專用類型。
• 從方法返回多個值。
• 在解構或模式匹配場景中簡化代碼。

C# 元組基於 System.ValueTuple 結構，引入於 .NET Framework 4.7 和 .NET Core 2.0。早期 C# 也支持 System.Tuple，但它是引用類型，性能較低且使用較繁瑣，因此現代 C# 更推薦使用 ValueTuple。

元組類型演進

傳統 Tuple 類 (C# 4.0+)

// 引用類型，位於 System 命名空間
Tuple<int, string, bool> oldTuple = Tuple.Create(1, "text", true);
Console.WriteLine(oldTuple.Item1); // 訪問元素

現代 ValueTuple 結構 (C# 7.0+)

// 值類型，性能更好，語法更簡潔
(int Id, string Name, bool Active) newTuple = (1, "text", true);
Console.WriteLine(newTuple.Id); // 使用命名元素訪問

兩種元組對比

ValueTuple 詳細用法

基本語法

// 隱式類型聲明
var tuple = (1, "hello", true);

// 顯式類型聲明
(int, string, bool) tuple = (1, "hello", true);

// 命名元素
(int Id, string Name, bool IsActive) person = (1, "John", true);

// 左側命名
var person = (Id: 1, Name: "John", IsActive: true);

元素訪問方式

var person = (Id: 1, Name: "John", IsActive: true);

// 通過名稱訪問
Console.WriteLine(person.Name); // "John"

// 通過位置訪問（依然可用）
Console.WriteLine(person.Item2); // "John"

// 解構賦值
var (id, name, isActive) = person;
Console.WriteLine(name); // "John"

// 部分解構
var (id, _, isActive) = person; // 忽略第二個元素

方法返回多個值

// 傳統方式（out 參數）
bool TryParse(string input, out int result, out string error) {
    // 解析邏輯
}

// 元組方式（更優雅）
(int Result, string Error) TryParse(string input) {
    if (int.TryParse(input, out var value))
        return (value, null);
    else
        return (0, "Invalid number");
}

// 使用示例
var (result, error) = TryParse("123");
if (error == null)
    Console.WriteLine($"Result: {result}");

高級特性與應用場景

模式匹配 (C# 8.0+)

var point = (X: 5, Y: 10);

// 位置模式
var quadrant = point switch {
    (0, 0) => "原點",
    (var x, var y) when x > 0 && y > 0 => "第一象限",
    (var x, var y) when x < 0 && y > 0 => "第二象限",
    _ => "其他象限"
};

LINQ 查詢中的元組

var people = new[] { 
    ("John", 25), 
    ("Jane", 30), 
    ("Bob", 25) 
};

// 分組查詢
var grouped = people
    .GroupBy(p => p.Item2)  // 按年齡分組
    .Select(g => (Age: g.Key, Count: g.Count(), Names: g.Select(p => p.Item1)))
    .ToList();

foreach (var group in grouped) {
    Console.WriteLine($"Age: {group.Age}, Count: {group.Count}");
}

異步方法中的元組

async Task<(bool Success, string Data)> FetchDataAsync() {
    try {
        var data = await httpClient.GetStringAsync("api/data");
        return (true, data);
    } catch {
        return (false, null);
    }
}

// 使用
var (success, data) = await FetchDataAsync();
if (success) {
    ProcessData(data);
}

元組操作與轉換

元組比較

var tuple1 = (1, "hello");
var tuple2 = (1, "hello");

// 值相等性比較
bool areEqual = tuple1 == tuple2; // true
bool areNotEqual = tuple1 != tuple2; // false

// 比較時考慮元素順序
var tuple3 = ("hello", 1);
bool areEqual2 = tuple1 == tuple3; // false，順序不同

元組賦值與解構

// 多重賦值
(int x, int y) = (10, 20);

// 交換變量（無需臨時變量）
(x, y) = (y, x);

// 方法返回解構
var (min, max) = FindMinMax(numbers);

// 與現有變量配合
int a = 5, b = 10;
(a, b) = (b, a); // 交換值

元組與集合的轉換

// 元組列表
List<(int Id, string Name)> people = new() {
    (1, "Alice"),
    (2, "Bob"),
    (3, "Charlie")
};

// 轉換為字典
Dictionary<int, string> dict = people.ToDictionary(p => p.Id, p => p.Name);

// 從集合創建元組
var stats = (Count: people.Count, AverageAge: people.Average(p => p.Id));

與其他特性的結合

元組與記錄類型

// 記錄類型提供更正式的數據結構
public record Person(int Id, string Name, DateTime BirthDate);

// 元組適合臨時、簡單的數據組合
(int Id, string Name) GetSimpleData() => (1, "John");

// 選擇依據：是否需要行為方法、驗證、繼承等

元組與 JSON 序列化

// System.Text.Json 支持元組序列化
var tuple = (Id: 1, Name: "John");
string json = JsonSerializer.Serialize(tuple);
// 結果: {"Item1":1,"Item2":"John"} - 注意名稱序列化

// 如果需要自定義名稱，使用 JsonPropertyName
[Serializable]
public struct MyTuple {
    [JsonPropertyName("id")] public int Item1 { get; set; }
    [JsonPropertyName("name")] public string Item2 { get; set; }
}

優勢

• 簡潔性：無需定義類或結構體即可快速組合多個值。
• 靈活性：支持不同類型的元素，且可以通過命名提高可讀性。
• 性能：基於 ValueTuple，是值類型，分配在棧上，性能優於舊的 System.Tuple（引用類型）。
• 解構支持：與解構語法結合，簡化變量賦值和數據提取。
• 方法返回值：方便從方法返回多個值，避免使用 out 參數或自定義類型。
• 與模式匹配結合：在 switch 表達式或 is 表達式中，元組可以用於模式匹配。

限制

• 可讀性問題：如果元組元素過多或命名不清晰，可能降低代碼可讀性。建議在複雜場景下使用類或結構體。
• 不可變性：元組是值類型，修改時需要重新賦值整個元組（不能直接修改某個字段）。
• 命名限制：編譯器不會強制命名一致性。例如，(x: 1, y: "test") 和 (a: 1, b: "test") 被視為兼容類型，儘管名稱不同。
• 序列化問題：元組不適合長期存儲或序列化（如 JSON），因為它們是臨時的、輕量級的數據結構。
• 與舊版兼容性：C# 7.0 之前的版本不支持 ValueTuple，需要引用 System.ValueTuple NuGet 包（在 .NET Framework 4.6.2 或更低版本中）。

使用建議

何時使用元組：

• 需要臨時組合少量數據。
• 從方法返回多個值。
• 用於模式匹配或解構場景。

何時避免元組：

• 數據結構複雜或需要長期維護時，使用類或結構體。
• 需要序列化或跨層傳遞數據時。
• 元組元素過多（通常建議不超過 4-5 個元素）。