下面是关于在C＃7.0语言中计划功能的说明。其中大部分功能在Visual Studio “15” Preview 4中能运行。现在是最好的试用时期，请记录下你们的想法。

C＃7.0语言增加了许多的新功能，促使专注于数据消费，简化代码和性能。

或许最大的特征是元组（tuples） ，使得它易于有多个结果，并从而简化代码是以对数据的形状为条件的模式匹配。但也有许多其他的一些功能希望将它们结合起来，让代码运行更高效，更明确，从而获得更多的创造性。如果有哪些运行不是你想要的或者有想改进的功能，在Visual Studio的窗口顶部使用“send feedback”功能将结果反馈给我们。在我所描述的许多功能在Preview 4还没有办法充分运行，根据用户的反馈结果，我们将在发布最终版是增加些新的功能。而必须要指出的是，现有计划中的一些功能在最终版也可能会有所改变或取消。

如果你对这个功能设置感兴趣并想学习它，在Roslyn GitHub site上可以找到许多的设计说明和相关讨论。

输出（out）变量

目前在C＃中，使用out参数并不像我们想象中那么流畅。在使用out参数调用方法时，你首先必须声明变量传递给它。虽然你通常不会初始化这些变量（他们将通过该方法后所有被覆盖），也不能使用VAR来声明他们，但是需要指定完整的类型：

public void PrintCoordinates(Point p)
{    int x, y; // have to "predeclare"p.GetCoordinates(out x, out y);WriteLine($"({x}, {y})");
}

在C＃7.0，我们增加了Out变量，作为out参数传递的点来声明一个变量权：

public void PrintCoordinates(Point p)
{p.GetCoordinates(out int x, out int y);WriteLine($"({x}, {y})");
}

需要注意的是，变量是在封闭块范围内，所以后续可以使用它们。大多数类型的语句不建立自己的适用范围，因此out变量通常在声明中被引入到封闭范围。

注：在Preview 4中，适用范围规则更为严格：out变量的作用域为它们在声明的说法。因此，上面的例子将会在下个版本中使用。

由于out变量直接声明作为参数传递给out参数，编译器通常可以告知类型（除非有冲突的过载）。所以这是很好用VAR，而不是一个类型来声明它们：

p.GetCoordinates(out var x, out var y);

out参数的一个常见的用途是Try...模式，其中out参数一个boolean return表示成功，out参数进行得到的结果：

public void PrintStars(string s)
{    if (int.TryParse(s, out var i)) { WriteLine(new string('*', i)); }    else {WriteLine("Cloudy - no stars tonight!"); }
}        

注：Preview 4处理的比较好的地方在于只是用if语句定义它。

计划允许“wildcards”作为out参数以及在*的形式，忽视不重要的out参数：

p.GetCoordinates(out int x, out *); // I only care about x

注：wildcards能否把它变成C#7.0还是个未知数。

模式匹配

C# 7.0 引入了模式的概念，抽象地说，这是一种语法成分可以用来测试一个值是否有一个一定的“形”以及在它起作用时从值里面获取到的额外信息。

下面是 C# 7.0 中关于模式的例子：

• c 的常量模式（c 是C#中的一个常量表达式），用于测试输入的参数是否和 c 相等

• T x 的类型模式（T 是一个类型，x 是一个标识符），用于测试输入的参数是否有类型 T，如果有，提取输入参数的值到一个 T 类型的新 x 变量中。

• var x 变量模式（x 是一个标识符），通常会匹配并简单地将输入参数的值放进一个新变量 x 中

这是个开始，模式是一种新的 C# 语言元素，而且我们将来可以把它们更多地增加到 C# 中。

在 C# 7.0 中，我们正在使用模式以增强两种已存在的语言结构：

• is 表达式现在在右边可以有一个模式，而不只是一个类型

• case 子句在 switch 语句中现在可以通过模式匹配，而不仅仅是常量值

在将来的C#中，我们或许会增加更多能使用模式的地方。

带模式的 Is 表达式

这是一个使用带有常量模式和类型模式的 is 表达式的例子：

public void PrintStars(object o)
{    if (o is null) return;     // constant pattern "null"    if (!(o is int i)) return; // type pattern "int i"WriteLine(new string('*', i));
}

正如你所看到的，模式变量（变量通过模式引入）与先前描述的 out 变量有些类似，他们可以在表达式中被声明，而且可以在它们最近的周围范围内被使用。也像 out 变量那样，模式变量是易变的，

注: 就像 out 变量一样，严格的范围规则适用于 Preview 4.

模式和 Try 方法通常会一起出现:

if (o is int i || (o is string s && int.TryParse(s, out i)) { /* use i */ }

带模式的 Switch 语句

我们正在泛化 switch 语句，因此：

• 你可以在任何类型上使用 switch（不仅仅是原始类型）
• 可以在 case 子句中使用模式
• Case 子句可以拥有额外的条件

这里是一个简单的例子：

switch(shape)
{case Circle c:WriteLine($"circle with radius {c.Radius}");break;case Rectangle s when (s.Length == s.Height):WriteLine($"{s.Length} x {s.Height} square");break;case Rectangle r:WriteLine($"{r.Length} x {r.Height} rectangle");break;default:WriteLine("<unknown shape>");break;case null:throw new ArgumentNullException(nameof(shape));
}

有几件关于这个新扩展的 switch 语句的事需要注意：

• case 子句的顺序现在很重要：就像 catch 子句，case 子句不再是必然不相交的，第一个子句匹配的将被选择。因此这里重要的是上面代码中 square case 比 rectangle case 来得要早。也是和 catch 子句一样，编译器会通过标记明显不能到达的情况来帮助你。在这之前，你永远无法知道评价的顺序，所以这不是一个重大改变的特性。
• 默认子句总是最后被评价：即使上面代码中 null 子句是最后才来，它会在默认子句被选择前被检查。这是为了与现有 switch 语义相兼容。然而，好的做法通常会让你把默认子句放到最后。
• null 子句在最后不可到达：这是因为类型模式遵循当前的 is 表达式的例子并且不会匹配空值。这保证了空值不会偶然被任何的类型模式捎来第一抢购。你必须更明确如何处理它们（或为默认子句留下他们）。

通过 case ...: 标签引入的模式变量仅存在于相对应的 switch 部分的范围内。

(string, string, string) LookupName(long id) // tuple return type
{... // retrieve first, middle and last from data storagereturn (first, middle, last); // tuple literal
}

var names = LookupName(id);
WriteLine($"found {names.Item1} {names.Item3}.");

(string first, string middle, string last) LookupName(long id) // tuple elements have names

var names = LookupName(id);
WriteLine($"found {names.first} {names.last}.");

return (first: first, middle: middle, last: last); // named tuple elements in a literal

(string first, string middle, string last) = LookupName(id1); // deconstructing decla
rationWriteLine($"found {first} {last}.");

(var first, var middle, var last) = LookupName(id1); // var inside

var (first, middle, last) = LookupName(id1); // var outside

(first, middle, last) = LookupName(id2); // deconstructing assignment

public void Deconstruct(out T1 x1, ..., out Tn xn) { ... }

class Point
{public int X { get; }public int Y { get; }public Point(int x, int y) { X = x; Y = y; }public void Deconstruct(out int x, out int y) { x = X; y = Y; }
}(var myX, var myY) = GetPoint(); // calls Deconstruct(out myX, out myY);

(var myX, *) = GetPoint(); // I only care about myX

public int Fibonacci(int x)
{if (x < 0) throw new ArgumentException("Less negativity please!", nameof(x));return Fib(x).current;(int current, int previous) Fib(int i){if (i == 0) return (1, 0);var (p, pp) = Fib(i - 1);return (p + pp, p);}
}

public IEnumerable<T> Filter<T>(IEnumerable<T> source, Func<T, bool> filter)
{if (source == null) throw new ArgumentNullException(nameof(source));if (filter == null) throw new ArgumentNullException(nameof(filter));return Iterator();IEnumerable<T> Iterator(){foreach (var element in source) {if (filter(element)) { yield return element; }}}
}