元组
元组提供了一种轻量级的方式，允许我们从一个方法中返回多个数据，而不需要自定义类或者使用out、ref等关键字，如：
public Tuple<int, string> GetTuple()
{
return new Tuple<int, string>(200, "OK");
}
上面是C#7.0之前的写法，从C#7.0开始，元组被分为两种：Tuple 和 ValueTuple，而上面的例子可以写成：
public (int, string) GetTuple()
{
return (200, "OK");
}
Tuple 和 ValueTuple的区别主要有：
1、Tuple是类（引用类型）、而ValueTuple是结构体（值类型）
2、Tuple中的每一项是只读的属性，而ValueTuple中的每一项都是字段，因此是可读可写的
Tuple还是原来那个Tuple，原来的配方，熟悉的味道，而ValueTuple是后来新加的类型，几乎所有Tuple能实现的地方，ValueTuple也能实现，而相比Tuple，ValueTuple又有许多不一样的地方：
1、声明与初始化
Tuple的初始化只能通过构造函数的参数传入，而ValueTuple则有多种形式，如：
//Tuple的初始化
Tuple<int, int> tuple1 = new Tuple<int, int>(1, 2);
var tuple2 = Tuple.Create<int, string>(200, "OK");
//ValueTuple的初始化
ValueTuple<int, int> valueTuple1 = (1, 2);//形如 (a,b,c,...) 格式的写法来初始化
var valueTuple2 = (1, 2);//使用var简化
(int, int) valueTuple3 = new ValueTuple<int, int>(1, 2);//new
var valueTuple4 = new ValueTuple<int, int>() { Item1 = 1, Item2 = 2 };//类似属性初始化
注：使用 (a,b,c...) 这样的格式初始化ValueTuple时至少需要两个元素，一个元素被括号当做运算符而非元组标志，如果要初始化一个元素的元组（没啥作用），需要使用new的方式
另外，Tuple和ValueTuple最多只支持8个泛型参数，如果还要多个，就必须使用第八参数Rest进行拓展，对于Tuple这无疑增加了初始化的难度，取值也不方便，而ValueTuple使用 (a,b,c,....) 这种格式的初始化可以很好地解决这个问题：
//初始化拥有20项的Tuple
var tuple = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int, int, int, int, int, Tuple<int, int, int, int, int, int>>>(
1, 2, 3, 4, 5, 6, 7, new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int, int, int, int>>(8, 9, 10, 11, 12, 13, 14,
new Tuple<int, int, int, int, int, int>(15, 16, 17, 18, 19, 20))
);
//Tuple取最后一个元素
int last_of_tuple = tuple.Rest.Rest.Item6;
//初始化拥有20项的ValueTuple
var valueTuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
//valueTuple类型是ValueTuple<int, int, int, int, int, int, int, ValueTuple<int, int, int, int, int, int, int, ValueTuple<int, int, int, int, int, int>>>
//ValueTuple取最后一个元素
var last_of_valueTuple1 = valueTuple.Rest.Rest.Item6;//方式一
var last_of_valueTuple2 = valueTuple.Item20;//方式二
2、ValueTuple可以声明元组每一项的名称
这个是Tuple的一个不足，因为每一项都是Item1、Item2等等，因此无法直观的知道Tuple中的每一项含义，因此Tuple的可读性一般都比较差。
为解决这个问题，ValueTuple因为可以从 (a,b,c...) 这样的格式初始化，于是就提供了一种自定义字段名称方式，如：
//方式一
(int count, double sum) tuple = (1, 3.14);
//方式二
var tuple = (count: 1, sum: 3.14);
//方式三
int count = 1;
double sum = 3.14;
var tuple = (count, sum);
//使用自定义的名称，而非Item1、Item2等
Console.WriteLine($"count:{tuple.count} sum:{tuple.sum}");
//当然，也可以使用Item1、Item2等
Console.WriteLine($"count:{tuple.Item1} sum:{tuple.Item2}");
上面有三种方式自定义字段名称，我们甚至可以将组合使用：
int a = 1;
var tuple = (a, b: "hello", true);
////使用自定义的名称，而非item1、item2等
Console.WriteLine($"a:{tuple.a} b:{tuple.b} c:{tuple.Item3}");
////当然，也可以使用item1、item2等
Console.WriteLine($"a:{tuple.Item1} b:{tuple.Item2} c:{tuple.Item3}");
但是自定义字段要求：
1、同一个元组内的自定义名称不能重复
2、自定义名称不能是元组中已存在的成员名称，如：Rest，ToString等
3、自定义名称可以是元组中存在的项，如Item1，但是顺序应该相同
例子：
var tuple = (count: 1, count: 1);//错误，名称重复
var tuple = (count: 1, Rest: 2, ToString: 3);//错误，不能是已存在的成员名称（Rest是第八项的名名称）
var tuple = (Item1: 1, Item3: 2);//错误，两元素元组只有Item1、Item2，名称可以是Item1和Item2，不能是Item3，同理三元素元组只有Item1、Item2、Item3，名称不能是Item4
var tuple = (Item2: 1, Item1: 2);//错误，顺序不对
注：自定义的名称只在编译时有效，在运行时还是会使用Item1、Item2等等，运行时通过反射也只会获取到Item1、Item2等属性字段，没有自定义的名称，换句话说，自定义的名称只是Item1、Item2等的别名
3、ValueTuple支持 == 和 != 运算符
因为ValueTuple是结构体，因此可以使用 == 和 != 来判断两个元组中的元素是否一样，而Tuple因为是引用类型，所以 == 和 != 运算符进行的是引用判断是否是同一实例：
//Tuple
bool b1 = new Tuple<int, string>(1, "abc") == new Tuple<int, string>(1, "abc");//false
//ValueTuple
bool b2 = new ValueTuple<int, string>(1, "abc") == new ValueTuple<int, string>(1, "abc");//true
bool b3 = new ValueTuple<int, string>(1, "abc") == (1, "abc");//true
bool b4 = (1, "abc") == (1, "abc");//true
//== 和 != 运算符与自定义的名称无关，只与顺序有关
bool b5 = (a: 1, b: "abc") == (1, "abc");//true
bool b6 = (1, b: "abc") == (code: 1, "abc");//true
var tuple = (a: 1, b: "abc");
int code = 1;
string message = "abc";
bool b7 = tuple == (code, message);//true
元组的 == 和 != 运算符比较规则是将两个元组中的相同位置的项进行 == 和 != 运算，因此，要求两个元组具有相同的结构及长度
4、赋值
ValueTuple比Tuple更实用还表现在赋值方面，如果是单个变量的赋值，两者的要求是一样的，就是要求元组具有相同的结构及长度。
但是ValueTuple在赋值方面玩出了新高度：
var point = (0, 90);
(int x, int y) = point;//定义两个变量并使用元组初始化
//(var x, var y) = point;//等价写法
//var (x, y) = point;//等价写法
int a = 0;
int b = 0;
(a, b) = point;//给已经声明过的变量赋值
这种赋值方法在某些场景值需要对多个变量赋值是很有用。
注：可能你会发现，Tuple也能这样赋值，其实这是解构在起作用
还有，某些情况下，我们可能只需要元组中的某些值，这个时候可以结合弃元一起使用：
var value = (1, true, "hello", 3.14);
(_, bool b, string str, _) = value;//取第二、三项
(_, _, _, var pi) = value;//取最后一项
(int i, _, _, _) = value;//取第一项
5、ValueTuple与Tuple之间的转换
ValueTuple与Tuple是两个不同的东西，两者之间并不能通过隐式或者显式的转换得到，但是可以通过现有的拓展类TupleExtensions中的拓展方法来实现转换：
//Tuple转ValueTuple
var tuple = new Tuple<int, string>(200, "OK");
var valueTuple = tuple.ToValueTuple();
Console.WriteLine($"{valueTuple.Item1}-{valueTuple.Item2}");
//ValueTuple转Tuple
var valueTuple = (200, "OK");
var tuple = valueTuple.ToTuple();
Console.WriteLine($"{tuple.Item1}-{tuple.Item2}");
如果TupleExtensions中的拓展方法不够用，可能就需要我们自行实现一个拓展方法了。
解构
在C#中，将对象转换为(a,b,c...) 这样的格式的过程称为解构。
一个对象、结构体、接口想要解构，需要提供一个 Deconstruct 方法，且需遵循下面的规则：
1、方法名必须是 Deconstruct
2、方法只能是实例方法或者拓展方法
3、方法返回类型必须是 void
4、方法的每一个参数必须使用out关键字修饰（这些参数对应(a,b,c...) 这样的格式中各项）
5、Deconstruct 方法运行重载，继承，但重载与参数类型无关，只与参数个数有关
.net框架中，给我们编译时预先定义好的Deconstruct 方法的类不多，比如Tuple，记录(record)、DictionaryEntry类等，其它情况下就可能需要我们自行根据这个规则来定义Deconstruct 方法了。
Deconstruct 方法可以是实例方法，可以直接定义，或者集成，或者实现接口得到，也可以重载，但是重载只与参数个数有关，而与参数类型无关。
比如实例方法：
interface IFather
{
void Deconstruct(out int a, out int b);
}
class Father : IFather
{
public void Deconstruct(out int a, out int b) => (a, b) = (1, 2);//解构赋值
public void Deconstruct(out int a, out int b, out string c) => (a, b, c) = (3, 4, "abc");//解构赋值
}
class Son : Father
{
}
static void Main(string[] args)
{
int a, b;
string c;
(a, b) = new Father();//类自身提供的Deconstruct
(a, b, c) = new Father();//类自身提供的Deconstruct重载
(a, b) = new Son();//子类继承的Deconstruct
(a, b, c) = new Son();//子类继承的Deconstruct
IFather father = new Father();
(a, b) = father;//接口提供的Deconstruct
}
Deconstruct方法也可以是拓展方法，我们可以重载，但是重载只与参数个数有关，而与参数类型无关。
基于拓展方法，我们就可以为已经定义好的类进行解构，比如结构DateTime，获取年月日等：
public static class DateTimeExtensions
{
public static void Deconstruct(this DateTime dateTime, out int year, out int month, out int day)
=> (year, month, day) = (dateTime.Year, dateTime.Month, dateTime.Day);//解构赋值
public static void Deconstruct(this DateTime dateTime, out int year, out int month, out int day, out int hour, out int minute, out int second)
=> (year, month, day, hour, minute, second) = (dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second);//解构赋值
}
static void Main(string[] args)
{
//直接取年月日
var (year, month, day) = DateTime.Now;
//或者
var (year, month, day, hour, minute, second) = DateTime.Now;
}
回过头来，前面说了，Tuple也能这样解构赋值，这就是因为Tuple有这样一个Deconstruct拓展方法，在TupleExtensions类中。
参考文档1：https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/functional/deconstruct
参考文档2：https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-tuples
标签：Tuple,C#,tuple,元组,int,var,new,解构,ValueTuple From： https://www.cnblogs.com/shanfeng1000/p/15003115.html