C#学习基本概念之Tuple类（元组、重数）
Tuple 类
提供用于创造元组对象的静态方法。
命名空间: System
程序集: mscorlib（位于 mscorlib.dll）
继承层次结构
System.Object
System.Tuple
语法：
public static class Tuple
方法
| 名称 | 说明 | |
|---|---|---|
  | Create<T1>(T1) | 创建新的 1 元组，即单一实例。 |
| Create<T1,T2>(T1,T2) | 创建新的 2 元组，即二元组。 |
| Create<T1,T2,T3>(T1,T2,T3) | 创建新的 3 元组，即三元组。 |
| Create<T1,T2,T3,T4>(T1,T2,T3,T4) | 创建新的 4 元组，即四元组。 |
| Create<T1,T2,T3,T4,T5>(T1,T2,T3,T4,T5) | 创建新的 5 元组，即五元组。 |
| Create<T1,T2,T3,T4,T5,T6>(T1,T2,T3,T4,T5,T6) | 创建新的 6 元组，即六元组。 |
| Create<T1,T2,T3,T4,T5,T6,T7>(T1,T2,T3,T4,T5,T6,T7) | 创建新的 7 元组，即七元组。 |
| Create<T1,T2,T3,T4,T5,T6,T7,T8>(T1,T2,T3,T4,T5,T6,T7,T8) | 创建新的 8 元组，即八元组。 |
备注
 说明 |
|---|
若要查看此类型的.NET Framework 源代码，请参阅 Reference Source。 您可以浏览源代码、 下载脱机查看参考资料和调试; 在逐句通过源 （包括修补程序和更新）see instructions. |
元组是具有特定数量和元素的序列的数据结构。 元组的示例是用来存储如人的名称标识符的第一个元素，第二个元素，并且此人的 income 中该年度第三个元素中的每一年中的数据结构具有三个元素 （称为 3 元组即三元组）。 .NET Framework 直接支持具有 1 到 7 元素的元组。 此外，您可以创建八个或多个元素的元组由嵌套在元组对象 Rest 属性 Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 对象。
元组通常使用四种方式︰
表示一组数据。 例如，一个元组可以表示的数据库记录，并且其组件可以表示每个字段的记录。
若要提供轻松访问和数据集的操作。
若要从方法返回多个值，而无需使用 out 参数 （在 C# 中) 或 ByRef 参数 （在 Visual Basic 中)。
若要将多个值传递给通过单个参数的方法。 例如， Thread.Start(Object) 方法只有一个参数，您可以提供一个值，则对该线程在启动时执行的方法。 如果您提供 Tuple<T1,T2,T3> 对象作为方法参数，则可以提供有三个项的数据的线程的启动例程。
Tuple 类不本身表示一个元组。 相反，它是一个类，提供用于创建.NET Framework 支持但元组类型的实例的静态方法。 它提供帮助器方法，您可以调用来实例化的元组对象，而无需显式指定元组的每个组件的类型。
虽然你可以通过调用其类构造函数创建元组类的实例，若要这样做的代码可以是很麻烦。 下面的示例使用类构造函数来创建的 7 元组或七元组，其中包含每次从 1950 年到 2000 年人口普查纽约市的人口数据。
C#
// Create a 7-tuple.var population = new Tuple<string, int, int, int, int, int, int>(
"New York", 7891957, 7781984,
7894862, 7071639, 7322564, 8008278);
// Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
population.Item1, population.Item7);
// The example displays the following output:
// Population of New York in 2000: 8,008,278
通过使用一个帮助器方法创建同一个元组对象是更为简单，如以下示例所示。
C#
// Create a 7-tuple.var population = Tuple.Create("New York", 7891957, 7781984, 7894862,
7071639, 7322564, 8008278);// Display the first and last elements.Console.WriteLine(
"Population of {0} in 2000: {1:N0}",
population.Item1, population.Item7);// The example displays the
following output:// Population of New York in 2000: 8,008,278
Create 帮助器方法直接支持包含一至八个组件 （即，单例到八元组） 的元组对象的创建。 尽管没有组件数没有实际限制可能具有一个元组，帮助器方法不能创建具有九个或多个组件的元组。 若要创建此类元组，必须调用 Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 构造函数。
| 说明 |
|---|
有关其他信息和使用元组的示例，请参阅.NET Framework 中的各个元组类型的文档。 在本主题末尾的另请参见部分中列出了这些。 |
示例
下面的示例创建一个 8 元组 （八元组），其中包含小于 20 的质数。
C#
var primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19);
Console.WriteLine("Prime numbers less than 20: " +
"{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}",
primes.Item1, primes.Item2, primes.Item3,
primes.Item4, primes.Item5, primes.Item6,
primes.Item7, primes.Rest.Item1);
// The example displays the following
output:
// Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19
备注：转自https://msdn.microsoft.com/zh-cn/library/system.tuple(v=vs.110).aspx
Tuple<T1,T2> 类
表示 2 元组，或二元组。
命名空间: System
程序集: mscorlib（位于 mscorlib.dll）
继承层次结构
语法
System.Object
System.Tuple<T1,T2>
[SerializableAttribute]public class Tuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable
类型参数
T1
元组的第一个分量的类型。
T2
元组的第二个分量的类型。
构造函数
| 名称 | 说明 | |
|---|---|---|
| Tuple<T1,T2>(T1,T2) | 初始化 Tuple<T1,T2> 类的新实例。 |
属性
| 名称 | 说明 | |
|---|---|---|
 | Item1 | 获取当前值 Tuple<T1,T2> 对象的第一个组件。 |
| Item2 | 获取当前值 Tuple<T1,T2> 对象的第二个组件。 |
方法
| 名称 | 说明 | |
|---|---|---|
| Equals(Object) | 返回一个值，该值指示是否当前 Tuple<T1,T2> 对象是否等于指定的对象。（覆盖 Object.Equals(Object)。） |
 | Finalize() | 在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。（继承自 Object。） |
| GetHashCode() | 返回当前哈希代码 Tuple<T1,T2> 对象。（覆盖 Object.GetHashCode()。） |
| GetType() | 获取当前实例的 Type。（继承自 Object。） |
| MemberwiseClone() | 创建当前 Object 的浅表副本。（继承自 Object。） |
| ToString() | 返回一个字符串，表示此值 Tuple<T1,T2> 实例。（覆盖 Object.ToString()。） |
显式接口实现
| 名称 | 说明 | |
|---|---|---|
  | IStructuralComparable.CompareTo(Object,IComparer) | 比较当前 Tuple<T1,T2> 对象与指定的对象使用指定的比较器，并返回一个整数，表示当前对象之前、 之后或在排序顺序中是位于指定对象的同一位置中。 |
| IStructuralEquatable.Equals(Object,IEqualityComparer) | 返回一个值，该值指示是否当前 Tuple<T1,T2> 对象是否等于指定的对象根据指定的比较方法。 |
| IStructuralEquatable.GetHashCode(IEqualityComparer) | 计算当前的哈希代码 Tuple<T1,T2> 通过使用指定的计算方法的对象。 |
| IComparable.CompareTo(Object) | 比较当前 Tuple<T1,T2> 对象与指定的对象，并返回一个整数，表示当前对象之前、 之后或在排序顺序中是位于指定对象的同一位置中。 |
备注
元组是具有特定数量和值序列的数据结构。 Tuple<T1,T2> 类表示 2 元组或对，这是一个具有两个组件的元组。 2 元组是类似于 KeyValuePair<TKey,TValue> 结构。
您可以实例化 Tuple<T1,T2> 对象通过调用 Tuple<T1,T2> 构造函数或静态 Tuple.Create<T1,T2>(T1,T2) 方法。 您可以使用只读方式检索元组的组件的值 Item1 和 Item2 实例属性。
元组通常使用四个不同的方式︰
表示一组数据。 例如，一个元组可以表示记录在数据库中，并且其组件可以表示该记录的字段。
若要提供轻松访问和数据集的操作。 下面的示例定义一个数组 Tuple<T1,T2> 对象，其中包含的学生和及其相应的名称测试分数。 它会接着循环要计算平均测验分数的数组。
using System;public class Example
{ public static void Main()
{
Tuple<string, Nullable<int>>[] scores =
{ new Tuple<string, Nullable<int>>("Jack", 78),
new Tuple<string, Nullable<int>>("Abbey", 92),
new Tuple<string, Nullable<int>>("Dave", 88),
new Tuple<string, Nullable<int>>("Sam", 91),
new Tuple<string, Nullable<int>>("Ed", null),
new Tuple<string, Nullable<int>>("Penelope", 82),
new Tuple<string, Nullable<int>>("Linda", 99),
new Tuple<string, Nullable<int>>("Judith", 84) };
int number;
double mean = ComputeMean(scores, out number);
Console.WriteLine("Average test score: {0:N2} (n={1})", mean, number);
} private static double ComputeMean(Tuple<string, Nullable<int>>[] scores,
out int n)
{
n = 0;
int sum = 0;
foreach (var score in scores)
{
if (score.Item2.HasValue)
{
n += 1;
sum += score.Item2.Value;
}
}
if (n > 0)
return sum / (double) n;
else
return 0;
}
}// The example displays the following output:
// Average test score: 88 (n=7)
从无需使用方法返回多个值 out 参数 （在 C# 中) 或 ByRef 参数 （在 Visual Basic 中)。 例如，下面的示例使用 Tuple<T1,T2> 对象以返回商和从整数除法得到的余数。
using System;public class Class1
{ public static void Main()
{ int dividend, divisor;
Tuple<int, int> result;
dividend = 136945; divisor = 178;
result = IntegerDivide(dividend, divisor);
if (result != null)
Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}",
dividend, divisor, result.Item1, result.Item2);
else
Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
dividend = Int32.MaxValue; divisor = -2073;
result = IntegerDivide(dividend, divisor); if (result != null)
Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}",
dividend, divisor, result.Item1, result.Item2);
else
Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
}
private static Tuple<int, int> IntegerDivide(int dividend, int divisor)
{
try {
int remainder;
int quotient = Math.DivRem(dividend, divisor, out remainder);
return new Tuple<int, int>(quotient, remainder);
}
catch (DivideByZeroException) {
return null;
}
}
}// The example displays the following output:
// 136945 \ 178 = 769, remainder 63
// 2147483647 \ -2073 = -1035930, remainder 757
若要将多个值传递给通过单个参数的方法。 例如， Thread.Start(Object) 方法只有一个参数，您可以提供一个值，则对该线程在启动时执行的方法。 如果您提供 Tuple<T1,T2> 对象作为方法参数，则可以提供具有两个项数据的线程的启动例程。
备注：转自：https://msdn.microsoft.com/zh-cn/library/dd268536(v=vs.110).aspx
转载于:https://blog.51cto.com/jiaojusuimu/1879991