参考手册
C# 教程
C# 语言值类型之结构
C# 语言之可为null值类型

C# 语言值类型之元组

元组的定义

元组功能在 C# 7.0 及更高版本中可用，它提供了简洁的语法，用于将多个数据元素分组成一个轻型数据结构。下面的示例演示了如何声明元组变量、对它进行初始化并访问其数据成员：

  1. (double, int) t1 = (4.5, 3);
  2. Console.WriteLine($"Tuple with elements {t1.Item1} and {t1.Item2}.");
  3. // 输出:
  4. // Tuple with elements 4.5 and 3.
  5. (double Sum, int Count) t2 = (4.5, 3);
  6. Console.WriteLine($"Sum of {t2.Count} elements is {t2.Sum}.");
  7. // 输出:
  8. // Sum of 3 elements is 4.5.

从 C# 7.3 开始，元组类型支持相等运算符 == 和 != 。元组类型是值类型，元组元素是公共字段。这使得元组为可变的值类型。

注意：元组功能需要 System.ValueTuple 类型和相关的泛型类型（例如 System.ValueTuple<T1,T2>），这些类型在.NET Core 和 .NETFramework 4.7 及更高版本中可用。若要在面向 .NETFramework 4.6.2 或更早版本的项目中使用元组，请将 NuGet 包System.ValueTuple 添加到项目。

可以使用任意数量的元素定义元组：

  1. var t =
  2. (1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
  3. 11, 12, 13, 14, 15, 16, 17, 18,
  4. 19, 20, 21, 22, 23, 24, 25, 26);
  5. Console.WriteLine(t.Item26);
  6. // 输出: 26

元组的用例

元组最常见的用例之一是作为方法返回类型。也就是说，你可以将方法结果分组为元组返回类型，而不需要定义 out 方法参数，如以下示例所示：

  1. var xs = new[] { 4, 7, 9 };
  2. var limits = FindMinMax(xs);
  3. Console.WriteLine($"Limits of [{string.Join(" ", xs)}] are {limits.min} and {limits.max}");
  4. // 输出:
  5. // Limits of [4 7 9] are 4 and 9
  6. var ys = new[] { -9, 0, 67, 100 };
  7. var (minimum, maximum) = FindMinMax(ys);
  8. Console.WriteLine($"Limits of [{string.Join(" ", ys)}] are {minimum} and {maximum}");
  9. // 输出:
  10. // Limits of [-9 0 67 100] are -9 and 100
  11. (int min, int max) FindMinMax(int[] input)
  12. {
  13.     if (input is null || input.Length == 0)
  14.     {
  15.         throw new ArgumentException("Cannot find minimum and maximum of a null or empty array.");
  16.     }
  17.     var min = int.MaxValue;
  18.     var max = int.MinValue;
  19.     foreach (var i in input)
  20.     {
  21.         if (i < min)
  22.         {
  23.             min = i;
  24.         }
  25.         if (i > max)
  26.         {
  27.             max = i;
  28.         }
  29.     }
  30.     return (min, max);
  31. }

如上面的示例所示，可以直接使用返回的元组实例，或者可以在单独的变量中析构它。还可以使用元组类型，而不是匿名类型。例如，在 LINQ 查询中。

通常，你会使用元组对相关的数据元素进行松散分组。这通常在专用和内部实用工具方法中有用。 对于公共 API 用例，请考虑定义 类 或 结构 类型。

元组字段名称

可以在元组初始化表达式中或元组类型的定义中显式指定元组字段的名称，如下面的示例所示：

  1. var t = (Sum: 4.5, Count: 3);
  2. Console.WriteLine($"Sum of {t.Count} elements is {t.Sum}.");
  3. (double Sum, int Count) d = (4.5, 3);
  4. Console.WriteLine($"Sum of {d.Count} elements is {d.Sum}.");

从 C# 7.1 开始，如果未指定字段名称，则可以根据元组初始化表达式中相应变量的名称推断出此名称，如下面的示例所示：

  1. var sum = 4.5;
  2. var count = 3;
  3. var t = (sum, count);
  4. Console.WriteLine($"Sum of {t.count} elements is {t.sum}.");

这称为元组投影初始值设定项。在以下情况下，变量名称不会被投影到元组字段名称中：

  • 候选名称是元组类型的成员名称，例如 Item3 、 ToString 或 Rest 。

  • 候选名称是另一元组的显式或隐式字段名称的重复项。

在这些情况下，你可以显式指定字段的名称，或按字段的默认名称访问字段。

元组字段的默认名称为 Item1 、 Item2 、 Item3 等。始终可以使用字段的默认名称，即使字段名称是显式指定的或推断出的，如下面的示例所示：

  1. var a = 1;
  2. var t = (a, b: 2, 3);
  3. Console.WriteLine($"The 1st element is {t.Item1} (same as {t.a}).");
  4. Console.WriteLine($"The 2nd element is {t.Item2} (same as {t.b}).");
  5. Console.WriteLine($"The 3rd element is {t.Item3}.");
  6. // 输出:
  7. // The 1st element is 1 (same as 1).
  8. // The 2nd element is 2 (same as 2).
  9. // The 3rd element is 3.

元组赋值和元组相等比较不会考虑字段名称。

在编译时，编译器会将非默认字段名称替换为相应的默认名称。因此，显式指定或推断的字段名称在运行时不可用。

元组赋值和析构

C# 支持满足以下两个条件的元组类型之间的赋值：

  • 两个元组类型有相同数量的元素

  • 对于每个元组位置，右侧元组元素的类型与左侧相应的元组元素的类型相同或可以隐式转换为左侧相应的元组元素的类型

元组元素是按照元组元素的顺序赋值的。元组字段的名称会被忽略且不会被赋值，如下面的示例所示：

  1. (int, double) t1 = (17, 3.14);
  2. (double First, double Second) t2 = (0.0, 1.0);
  3. t2 = t1;
  4. Console.WriteLine($"{nameof(t2)}: {t2.First} and {t2.Second}");
  5. // 输出:
  6. // t2: 17 and 3.14
  7. (double A, double B) t3 = (2.0, 3.0);
  8. t3 = t2;
  9. Console.WriteLine($"{nameof(t3)}: {t3.A} and {t3.B}");
  10. // 输出:
  11. // t3: 17 and 3.14

还可以使用赋值运算符 = 在单独的变量中析构元组实例。为此，可以使用以下方式之一进行操作：

  • 在括号内显式声明每个变量的类型：

    1.   var t = ("post office", 3.6);
    2.   (string destination, double distance) = t;
    3.   Console.WriteLine($"Distance to {destination} is {distance} kilometers.");
    4.   // 输出:
    5.   // Distance to post office is 3.6 kilometers.

  • 在括号外使用 var 关键字来声明隐式类型化变量，并让编译器推断其类型：

    1.   var t = ("post office", 3.6);
    2.   var (destination, distance) = t;
    3.   Console.WriteLine($"Distance to {destination} is {distance} kilometers.");
    4.   // 输出:
    5.   // Distance to post office is 3.6 kilometers.

  • 使用现有变量：

    1.   var destination = string.Empty;
    2.   var distance = 0.0;
    3.   var t = ("post office", 3.6);
    4.   (destination, distance) = t;
    5.   Console.WriteLine($"Distance to {destination} is {distance} kilometers.");
    6.   // 输出:
    7.   // Distance to post office is 3.6 kilometers.

元组相等

从 C# 7.3 开始，元组类型支持 == 和 != 运算符。这些运算符按照元组元素的顺序将左侧操作数的成员与相应的右侧操作数的成员进行比较。

  1. (int a, byte b) left = (5, 10);
  2. (long a, int b) right = (5, 10);
  3. Console.WriteLine(left == right); // 输出: True
  4. Console.WriteLine(left != right); // 输出: False
  5. var t1 = (A: 5, B: 10);
  6. var t2 = (B: 5, A: 10);
  7. Console.WriteLine(t1 == t2); // 输出: True
  8. Console.WriteLine(t1 != t2); // 输出: Fals

如上面的示例所示， == 和 != 操作不会考虑元组字段名称。同时满足以下两个条件时，两个元组可比较：

  • 两个元组具有相同数量的元素。 例如，如果 t1 和 t2 具有不同数目的元素，t1 != t2 则不会进行编译。

  • 对于每个元组位置，可以使用 == 和 != 运算符对左右侧元组操作数中的相应元素进行比较。 例如，(1, (2, 3)) == ((1, 2), 3) 不会进行编译，因为 1 不可与 (1, 2) 比较。

== 和 != 运算符将以短路方式对元组进行比较。也就是说，一旦遇见一对不相等的元素或达到元组的末尾，操作将立即停止。但是，在进行任何比较之前，将对所有元组元素进行计算，如以下示例所示：

  1. Console.WriteLine((Display(1), Display(2)) == (Display(3), Display(4)));
  2. int Display(int s)
  3. {
  4.     Console.WriteLine(s);
  5.     return s;
  6. }
  7. // 输出:
  8. // 1
  9. // 2
  10. // 3
  11. // 4
  12. // False

元组作为 out 参数

通常，你会将具有 out 参数的方法重构为返回元组的方法。但是，在某些情况下， out 参数可以是元组类型。

下面的示例演示了如何将元组作为 out 参数使用：

  1. var limitsLookup = new Dictionary<int, (int Min, int Max)>()
  2. {
  3.     [2] = (4, 10),
  4.     [4] = (10, 20),
  5.     [6] = (0, 23)
  6. };
  7. if (limitsLookup.TryGetValue(4, out (int Min, int Max) limits))
  8. {
  9.     Console.WriteLine($"Found limits: min is {limits.Min}, max is {limits.Max}");
  10. }
  11. // 输出:
  12. // Found limits: min is 10, max is 20

元组与 System.Tuple

System.ValueTuple 类型支持的 C# 元组不同于 System.Tuple 类型表示的元组。主要区别如下：

  • ValueTuple 类型是值类型。 Tuple 类型是引用类型。

  • ValueTuple 类型是可变的。 Tuple 类型是不可变的。

  • ValueTuple 类型的数据成员是字段。 Tuple 类型的数据成员是属性。

C# 语言值类型之结构
C# 语言之可为null值类型

分类导航

C 语言C++C#JavaPHPPYTHONGONode.jsPandasR 语言DjangoMatplotlibVB 教程ABAP 教程Fiori 教程汇编语言.NET Core 教程Fortran 教程ASP.NET Core 教程Vue 教程Numpy机器学习SciPy