C# 7.0 語言新特性

　　以下是關於在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 部分的范围内。

　　元组

　　这是常见的希望从一个方法返回多个值的做法。目前可用的选项不是最佳的：

• Out 参数。使用笨拙（即便有上面描述到的提升），它们不使用异步的方法运行。

• 
  

• System.Tuple<...>  返回类型。使用累赘并且需要一个元组对象的分配。

• 
  

• 为每个方法定制传输类型：大量的代码为了类型开销的目的仅是临时收集一些值

• 
  

• 匿名类型通过返回一个 dynamic 返回类型。高性能开销并且没有静态类型检查。

　　为了在这方面做得更好，C# 添加了tuple types 和 tuple literals:

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

　　这个方法目前有效地返回三个字符串，将其作为元素在元组类型里包裹起来。

　　方法的调用者将会接受到一个元组，并且可以逐一访问元素。

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

　　Item1 等等，是元组元素的默认名字，并能够经常被使用。但它们不是太好描述的，因此你可以选择性地添加更好的一个。

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

　　现在元组的接受者拥有更多的可描述的名字用于运行：

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

　　你也可以在 tuple literals 中直接指定名字：

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

　　通常来说，你可以互相分配元组类型无关的名字，只要独立的元素是可以被分配的，元组类型会自如 转换成其他元组类型。特别是对于 tuple literals ，存在一些限制，这会警告或提示在常见的错误的情况下提示，例如偶然交换元素的名字。

注意：这些限制还没在 Preview 4 中实现

　　元组是值类型，而且他们的元素只是公开、易变的域。他们的值相等，代表这两个元组是相等的（都有相同的哈斯码）如果它们的元素都结对匹配（都有相同的哈斯码）。

　　这使得元组对于在多种返回值下的很多情况十分有用。举例来说，如果你需要一个有多种键的词典，使用元组作为你的键，然后一切东西就会如常工作。如果你需要在每个位置有一个有多种值的列表，使用元组，查找列表等等，程序会正常运行。

注意：元组依赖一系列底层类型，它们在 Preview 4 中不被引入。为了将来的工作，你可以通过 NuGget 轻易获取它们： 在 Solution Explorer 中右键点击项目，并选择“Manage NuGet Packages…” 选择“Browse”选项卡，检查“Include prerelease” 并且选择“nuget.org”作为“Package source” 搜索“System.ValueTuple”并安装它

　　解构

　　另一种消除元组（tuple）的方法是解构元组。通过一个解构声明语法，把一个元组（或者其他的值）拆分为几部分，并且重新定义为新的变量。

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

　　在解构中可采用var关键字：

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

　　或者把var关键字提取出来，在括号外：

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

   注：仍然还没有确定是否将通配符引入C# 7.0中。

　　局部函数

　　有时，一个辅助函数只在一个使用它的单一方法内部有意义。现在你可以在其他功能体内部声明这些函数作为一个局部函数：

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);
    }
}

　　参数和闭合区间局部变量可用在局部函数内，类似lambda表达式。

　　举一个例子，方法实现迭代器通常需要严格检查调用时非迭代器封装方法。（迭代器本身没有运行，只到调用MoveNext 才会运行）。局部函数在这种情况下是完美的：

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; }
        }
    }
}

　　如果迭代器是一个私有方法的下一个过滤器，它将有可能被其他成员不小心使用（没有参数检查）。此外，作为过滤器，它将需要采取所有的相同的参数，而不是指定域内的参数。

   注：在Preview 4版本中，本地函数必须在它们被调用之前声明。这个限制将被放松，能调用读取直接赋值的局部变量。

　　Literal 改进

　　C# 7.0 允许使用“_”作为数字分隔符在数字literals中：

var d = 123_456;
var x = 0xAB_CD_EF;

　　你可以把它放在你想要的位置，提升可读性。这样对数值没有任何影响。

　　此外，C# 7.0也介绍了二进制literals，这样你可以直接指定二进制模式而不必知道十六进制符号。

var b = 0b1010_1011_1100_1101_1110_1111;

　　Ref 返回和本地

　　就像你可以通过reference（用ref修饰符）在C＃中传递东西，您现在可以通过reference return 他们，并通过 reference将它们存储在局部变量中。

public ref int Find(int number, int[] numbers)
{
    for (int i = 0; i < numbers.Length; i++)
    {
        if (numbers[i] == number) 
        {
            return ref numbers[i]; // return the storage location, not the value
        }
    }
    throw new IndexOutOfRangeException($"{nameof(number)} not found");
}

int[] array = { 1, 15, -39, 0, 7, 14, -12 };
ref int place = ref Find(7, array); // aliases 7&#39;s place in the array
place = 9; // replaces 7 with 9 in the array
WriteLine(array[4]); // prints 9

　　这对绕过占位符成为大数据结构是非常有用的。举例来说，一个游戏可能会在一个大的预分配数组结构中保存其数据（为避免垃圾收集暂停）。Methods 可以直接返回一个 reference 到这样一个结构，且通过调用者可以读取和修改它。

　　这里有一些限制，以确保这是安全的：

• 你可以只返回 refs 那些是 “安全返回（safe to return）”的:那些被传递给你的，和那些点到对象的字段。

• 
  

• Ref locals被初始化为某一存储位置，并且不能突变到指向另一个。

　　广义异步返回类型

　　截至目前为止，在C＃调用异步方法必须要返回void，Task或Task。C＃7.0允许以这样的方式来定义其它类型，从而使它们可以从异步方法返回。

　　例如，我们计划有一个ValueTask结构类型。它是建立在预防Task 对象的分配时，异步操作的结果是已在可等候的时间的情况下。对于很多异步场景，比如以涉及缓冲为例， 这可以大大减少分配的数量，并使性能有显著提升。

　　这里有许多其他的方法可以让您想象自定义“task-like”类型是有用的。它不会是简单的正确创建，所以我们不要指望大多数人推出自己的，但他们很可能将会开始在框架和API展现出来，然后调用方可以返回并await他们今天做任务（Tasks）的方式。

    注：广义异步返回类型尚未应用在预览4。    

　　更多 Expression-bodied 方法

　　Expression-bodied 方法、属性等都是C# 6.0的重大突破，但并不允许他们在各种各样的member中使用，C#7.0添加了访问器、构造函数和终结器等，使更多member可以使用Expression-bodied 方法：

class Person
{
    private static ConcurrentDictionary<int, string> names = new ConcurrentDictionary<int, string>();
    private int id = GetId();

    public Person(string name) => names.TryAdd(id, name); // constructors
    ~Person() => names.TryRemove(id, out *);              // destructors
    public string Name
    {
        get => names[id];                                 // getters
        set => names[id] = value;                         // setters
    }
}

注：这些额外的Expression-bodied 方法还没有工作在预览4。

　　这是一个由社区贡献的特征，而非微软C#团队。并且，开源！

　　在表达式的中间抛出一个异常是很容易的，只需要为你自己调用一个方法，但在C#7.0中我们允许在一些地方直接抛出表达式：

class Person
{
    public string Name { get; }
    public Person(string name) => Name = name ?? throw new ArgumentNullException(name);
    public string GetFirstName()
    {
        var parts = Name.Split(" ");
        return (parts.Length > 0) ? parts[0] : throw new InvalidOperationException("No name!");
    }
    public string GetLastName() => throw new NotImplementedException();
}

  注：抛出表达式还未在预览4工作。

　　本文地址：http://www.oschina.net/translate/whats-new-in-csharp-7-0

　　原文地址：https://blogs.msdn.microsoft.com/dotnet/2016/08/24/whats-new-in-csharp-7-0/

以上是C# 7.0 語言新特性的詳細內容。更多資訊請關注PHP中文網其他相關文章！