C#7.0新增元组

定义：

//此赋值会创建其成员为 Item1 和 Item2 的元组，其使用方式与 Tuple 的相同。
var letters = ("a", "b");

//namedLetters 元组包含称为 Alpha 和 Beta 的字段。
(string Alpha, string Beta) namedLetters = ("a", "b");

//还可以指定赋值右侧的字段的名称
var alphabetStart = (Alpha: "a", Beta: "b");

//生成警告 CS8123，告知你赋值右侧的名称 Alpha 和 Beta 将被忽略，
//因为它们与左侧的名称 First 和 Second 冲突。
(string First, string Second) firstLetters = (Alpha: "a", Beta: "b");

 使用

元组在作为 private 和 internal 方法的返回类型时是最有用的。 元组为这些方法提供了简单的语法以返回多个离散值：不用再费心创作定义返回类型的 class 或 struct。 无需创建新类型。

public static double StandardDeviation(IEnumerable<double> sequence)
{
    (int Count, double Sum, double SumOfSquares) computation = ComputeSumsAnSumOfSquares(sequence);

    var variance = computation.SumOfSquares - computation.Sum * computation.Sum / computation.Count;
    return Math.Sqrt(variance / computation.Count);
}

private static (int Count, double Sum, double SumOfSquares) ComputeSumsAnSumOfSquares(IEnumerable<double> sequence)
{
    var computation = (count: 0, sum: 0.0, sumOfSquares: 0.0);

    foreach (var item in sequence)
    {
        computation.count++;
        computation.sum += item;
        computation.sumOfSquares += item * item;
    }

    return computation;
}

 

析构

//1
 (int count, double sum, double sumOfSquares) = ComputeSumAndSumOfSquares(sequence);
//2
var (sum, sumOfSquares, count) = ComputeSumAndSumOfSquares(sequence);
//3
(double sum, var sumOfSquares, var count) = ComputeSumAndSumOfSquares(sequence);
//4析构赋值
public class Point
{
    public int X { get; set; }
    public int Y { get; set; }

    public Point(int x, int y) => (X, Y) = (x, y);
}

 

析构用户定义类型

定义一个Deconstruct函数，参数加out

public class Point
{
    public Point(double x, double y)
    {
        this.X = x;
        this.Y = y;
    }

    public double X { get; }
    public double Y { get; }

    public void Deconstruct(out double x, out double y)
    {
        x = this.X;
        y = this.Y;
    }
}

var p = new Point(3.14, 2.71);
(double X, double Y) = p;

 

弃元

通常，在进行元组解构或使用 out 参数调用方法时，必须定义一个其值无关紧要且你不打算使用的变量。 为处理此情况，C# 增添了对弃元的支持。 弃元是一个名为 _（下划线字符）的只写变量，可向单个变量赋予要放弃的所有值。 弃元类似于未赋值的变量；不可在代码中使用弃元（赋值语句除外）。

在以下方案中支持弃元：

 

• 在对元组或用户定义的类型进行解构时。

• 在使用 out 参数调用方法时。

• 在使用 is 和 switch 语句匹配操作的模式中。

• 在要将某赋值的值显式标识为弃元时用作独立标识符。

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
       var (_, _, _, pop1, _, pop2) = QueryCityDataForYears("New York City", 1960, 2010);

       Console.WriteLine($"Population change, 1960 to 2010: {pop2 - pop1:N0}");
   }
   
   private static (string, double, int, int, int, int) QueryCityDataForYears(string name, int year1, int year2)
   {
      int population1 = 0, population2 = 0;
      double area = 0;
      
      if (name == "New York City") {
         area = 468.48; 
         if (year1 == 1960) {
            population1 = 7781984;
         }
         if (year2 == 2010) {
            population2 = 8175133;
         }
      return (name, area, year1, population1, year2, population2);
      }

      return ("", 0, 0, 0, 0, 0);
   }
}
// The example displays the following output:
//      Population change, 1960 to 2010: 393,149