前言
如今 C# 雖然發展到了 8.0 版本，引入了諸多的函式式特性，但其實在 C# 未來的規劃當中，還有很多足以大規模影響現有 C# 代碼結構和組成的特性，本文中將會對就重要的特性進行介紹，并用代碼示例展示這些特性，
以下特性將會在 C# 9.0、10.0 或者更高版本提供，
Records
Records 是一種全新的簡化的 C# class 和 struct 的形式，
現在當我們需要宣告一個型別用來保存資料，并且支持資料的解構的話，需要像如下一樣寫出大量的樣板代碼：
class Point : IEquatable<Point>
{
public readonly double X;
public readonly double Y;
public Point(double X, double Y)
{
this.X = X;
this.Y = Y;
}
public static bool operator==(Point left, Point right) { ... }
public bool Equals(Point other) { ... }
public override bool Equals(object other) { ... }
public override int GetHashCode() { ... }
public void Deconstruct(out double x, out double y) { ... }
}
十分復雜，引入 Records 之后，上面的樣板代碼只需簡化成一句話：
data class Point(double X, double Y);
并且 Records 支持資料的變換、解構和模式匹配：
var pointA = new Point(3, 5);
var pointB = pointA with { Y = 7 };
var pointC = new Point(3, 7);
// 當 Y = 5 時為 X，否則為 Y
var result = pointB switch
{
(var first, 5) => first,
(_, var second) => second
};
// true
Console.WriteLine(pointB == pointC);
當然，record 是 immutable 的，并且是可以合并（繼承）的，也可以標記為 sealed 或者 abstract：
sealed data class Point3D(double X, double Y, double Z) : Point(X, Y);
上面的這種 record 宣告方式是基于位置宣告的，即 Point(first, second)，fisrt 所代表的第一個位置將成為 X，second 所代表的第二個位置將成為 Y，
還有一種宣告方式是基于名稱的：
data class Point { double X; double Y };
var point = new Point { X = 5, Y = 6 };
Discriminated Unions
Discriminated unions 又叫做 enum class，這是一種全新的型別宣告方式，顧名思義，是型別的 “列舉”，
例如，我們需要定義形狀，形狀有矩形、三角形和圓形，以前我們需要先撰寫一個 Shape 類，然后再創建 Rectangle、Triangle 和 Circle 類繼承 Shape 類，現在只需要幾行就能完成，并且支持模式匹配和解構：
enum class Shape
{
Retangle(double Width, double Height);
Triangle(double Bottom, double Height);
Circle(double Radius);
Nothing;
}
然后我們就可以使用啦：
var circle = new Circle(5);
var rec = new Rectangle(3, 4);
if (rec is Retangle(_, 4))
{
Console.WriteLine("這不是我想要的矩形");
}
var height = GetHeight(rec);
double GetHeight(Shape shape)
=> shape switch
{
Retangle(_, height) => height,
Triangle(_, height) => height,
_ => throw new NotSupportedException()
};
利用此特性，我們可以輕而易舉的實作支持模式匹配的、type sound 的可空資料結構：
enum class Option<T>
{
Some(T value);
None;
}
var x = Some(5);
// Option<never>
var y = None;
void Foo(Option<T> value)
{
var bar = value switch
{
Some(var x) => x,
None => throw new NullReferenceException()
};
}
Union and Intersection Types
當我們想要表示一個物件是兩種型別其一時，將可以使用聯合型別來表達：
public type SignedNumber = short | int | long | float | double | decimal;
public type ResultModel<T> = DataModel<T> | ErrorModel;
這在 Web API 中非常有用，當我們的介面可能回傳錯誤的時候，我們不再需要將我們的資料用以下方式包含在一個統一的模式中：
public class ResultModel<T>
{
public string Message { get; set; }
public int Code { get; set; }
public T Data { get; set; }
}
我們將能夠做到，不依賴例外等流程處理的方式做到錯誤時回傳錯誤資訊，請求正常處理時回傳真實所需的資料：
public async ValueTask<DataModel | ErrorModel> SomeApi()
{
if (...) return new DataModel(...);
return new ErrorModel(...);
}
還有和型別，用來表示多個型別之和，我們此前在設計介面時，如果需要一個型別實作了多個介面，則需要定義一個新介面去實作之前的介面：
interface IA { ... }
interface IB { ... }
interface IAB : IA, IB { }
void Foo(IAB obj) { ... }
有了和型別之后，樣板代碼 IAB 將不再需要：
void Foo(IA & IB obj) { ... }
或者我們也可以這樣宣告新的型別：
type IAB = IA & IB;
Bottom Type
Bottom type 是一種特殊的型別 never，never 型別是任何型別的子類，因此不存在該型別的子類，一個 never 型別的什么都不表示，
Union types 帶來一個問題，就是我們有時候需要表達這個東西什么都不是，那么 never 將是一個非常合適的選擇：
type Foo = Bar | Baz | never;
另外，never 還有一個重要的用途：控制代碼流程，一個回傳 never 的函式將結束呼叫者的邏輯，即這個函式不會回傳：
void | never Foo(int x)
{
if (x > 5) return;
return never;
}
void Main()
{
Foo(6);
Console.WriteLine(1);
Foo(4);
Console.WriteLine(2);
}
上述代碼將只會輸出 1，
Concepts
Concepts 又叫做 type classes、traits，這個特性做到可以在不修改原有型別的基礎上，為型別實作介面，
首先我們定義一個 concept：
concept Monoid<T>
{
// 加函式
T Append(this T x, T y);
// 零屬性
static T Zero { get; }
}
然后我們可以為這個 concept 創建型別類的實體：
instance IntMonoid : Monoid<int>
{
int Append(this int x, int y) => x + y;
static int Zero => 0;
}
這樣我們就為 int 型別實作了 Monoid<int> 介面，
當我們想實作一個函式用來將一個 int 陣列中的所有元素求和時，只需要：
public T Sum<T, inferred M>(T[] array) where M : Monoid<T>
{
T acc = M.Zero;
foreach (var i in array) acc = acc.Append(i);
return acc;
}
注意到，型別 M 會根據 T 進行自動推導得到 Monoid<int>，
這樣我們就能做到在不需要修改 int 的定義的情況下為其實作介面，
Higher Kinded Polymorphism
Higher kinded polymorphism，又叫做 templated template，或者 generics on generics，這是一種高階的多型，
舉個例子，比如當我們需要表達一個型別是一個一階泛型型別，且是實作了 ICollection<> 的容器之一時，我們可以寫：
void Foo<T>() where T : <>, ICollection<>, new();
有了這個特性我們可以輕而易舉的實作 monads，
例如我們想要做一個將 IEnumerable<> 中所有元素變成某種集合型別的時候，例如 ToList() 等，我們就不需要顯式地實作每一種需要的型別的情況（例如 List<>）：List<T> ToList(this IEnumerable<T> src)了，
我們只需要這么寫：
T<X> To<T, X>(this IEnumerable<X> xs) where T : <>, ICollection<>, new()
{
var result = new T<X>();
foreach (var x in xs) result.Add(x);
return result;
}
當我們想要把一個 IEnumerable<int> x 轉換成 List<int> 時，我們只需簡單的呼叫：x.To<List<>>() 即可，
Simple Programs
該特性允許撰寫 C# 代碼時，無需 Main 函式，直接像寫腳本一樣直接在檔案中撰寫邏輯代碼，以此簡化撰寫少量代碼時卻需要書寫大量樣板代碼的問題：
以前寫代碼：
namespace Foo
{
class Bar
{
static async Task Main(string[] args)
{
await Task.Delay(1000);
Console.WriteLine("Hello world!");
}
}
}
現在寫代碼：
await Task.Delay(1000);
Console.WriteLine("Hello world!");
Expression Blocks
該特性允許創建運算式塊：
Func<int, int, bool> greaterThan = (a, b) => if (a > b) a else b;
// true
greaterThan(5, 4);
因此有了以上特性，我們可以利用運算式實作更加復雜的東西，
后記
以上特性都是對代碼布局和組成影響非常大的特性，并且不少特性幾年前就已經被官方實作，但是因為存在尚未討論解決的問題，遲遲沒有發布進產品，
除此之外，還有幾十個用于改進語言和方便用戶使用等等的小特性也在未來的規劃當中，此處不進行介紹，
未來的 C# 和今天的 C# 區別是很大的，作為一門多范式語言，C# 正在朝遠離 Pure OOP 的方向漸行漸遠，期待這門語言變得越來越好，
轉載請註明出處，本文鏈接：https://www.uj5u.com/net/59630.html
標籤：.NET Core