C# 版本历史记录
说明：因为Markdown下维护这样复杂的表格有一点麻烦，故，这里以图片形式展示出来，如后续内容有更新，请点击 这里 访问原始笔记链接。为知笔记 的表格渲染在移动端表现不佳，为了获得更好的阅读体验，请在电脑端访问查看。
C# 版本特性说明
现在是 2021 年，相信 C# 7.0 以前的版本大家都应该没有什么问题，因为像博主这样的 90 后“中年”男人，接触的都是这个版本的 C#。所以，在这里我们主要讲解大家C# 7.0、8.0 以及 9.0 的语法特性。考虑到文章篇幅有限，这里选取的都是博主个人比较喜欢的语法特性，如果这里没有你喜欢的特性，请参考文章末尾的参考链接。如果这里的特性你都不喜欢，请你马上关掉这个网页，愿这个世界：Love & Peace。可能你会感觉到我说话变得小心翼翼起来，因为这个世界上有种叫做“杠精”的生物，当它从我的只言片语里读出那些挫败感的时候，终于有了嘲笑我们这批步入30岁行列的90后的底气，没错，我在最近的博客评论中被读者“嘲讽”了，让暴风雨来得更猛烈一些吧！
C# 7.0
在 C# 7.0 中，我个人比较喜欢的特性主要有以下几个：元组和弃元、更多的 expression-bodied 成员、out 变量、异步 Main 方法、模式匹配 和 引发表达式。
元组和弃元
这个概念乍听起来可能会有一点陌生，其实，按我的理解，这就是增强的元组语法，终于可以摆脱Item1、Item2……啦：
1 //示例1
2(string Alpha, string Beta) namedLetters = ("a", "b");
3Console.WriteLine($"{namedLetters.Alpha}, {namedLetters.Beta}");
4 //示例2
5var alphabetStart = (Alpha: "a", Beta: "b");
6Console.WriteLine($"{alphabetStart.Alpha}, {alphabetStart.Beta}");
7//示例3
8int count = 5;
9string label = "Colors used in the map";
10var pair = (count, label);
11Console.WriteLine(pair);
有一段时间，前端同事总和我吹嘘 ES6 里面的解构多么多么好用！对此，我想说，C# 一样可以解构，假设我们现在有下面的一个方法：
1static (string, double, double) GetLocation()
2 {
3 var city = "西安市";
4 var lat = 33.42d;
5 var lon = 107.40d;
6 return (city, lon, lat);
7}
这就是简化后的元组的用法，如果是以前，我们还需要返回一个Tuple<string, double, double>。此时，如果我们需要解析城市名称及其经纬度，可以这样做：
1//示例4
2(string city, double lon, double lat) = GetLocation();
3Console.WriteLine($"{city},({lon},{lat})");
OK，那么什么又是弃元呢？继续以上面的代码为例，如果我不关心经纬度，只需要城市名称又该怎么办呢？人家的方法返回的是一个3元的结果，而我们只需要其中的1元，此时，就有了所谓弃元的概念：
1(string city, _, _) = GetLocation();
2Console.WriteLine($"{city}");
在 C# 中可以使用下划线_来表示要舍弃的元，是为弃元，怎么样？你学会了吗？
更多的 expression-bodied 成员
这部分同样是经过强化的 Lambda 表达式，之前我们可以在成员函数和 只读属性上使用 Lambda 表达式，而现在，我们可以将其运用在构造函数、终结器以及 get和set 访问器：
1// Expression-bodied constructor
2public ExpressionMembersExample(string label) => this.Label = label;
3
4// Expression-bodied finalizer
5~ExpressionMembersExample() => Console.Error.WriteLine("Finalized!");
6
7private string label;
8
9// Expression-bodied get / set accessors.
10public string Label
11{
12 get => label;
13 set => this.label = value ?? "Default label";
14}
out变量
个人认为，这是一个非常不错的改进，终于不用再单独声明out变量啦：
if (int.TryParse(input, out int result))
Console.WriteLine(result);
else
Console.WriteLine("Could not parse input");
异步 Main 方法
顾名思义，Main 方法现在可以支持 async 关键字啦：
static async Task<int> Main()
{
// This could also be replaced with the body
// DoAsyncWork, including its await expressions:
return await DoAsyncWork();
}
在没有返回值的情况下，可以考虑返回Task:
static async Task Main()
{
await SomeAsyncMethod();
}
模式匹配
主要是针对 is 和 switch 语句提供了增强的语法。在这里，对于前者来说，我们可以将判断和赋值两个步骤合二为一：
1public static double ComputeAreaModernIs(object shape)
2{
3 if (shape is Square s)
4 return s.Side * s.Side;
5 else if (shape is Circle c)
6 return c.Radius * c.Radius * Math.PI;
7 else if (shape is Rectangle r)
8 return r.Height * r.Length;
9 // elided
10 throw new ArgumentException(
11 message: "shape is not a recognized shape",
12 paramName: nameof(shape));
13}
而对于后者来说，主要打破了传统 switch 语句的常量模式：
1public static double ComputeArea_Version3(object shape)
2{
3 switch (shape)
4 {
5 case Square s when s.Side == 0:
6 case Circle c when c.Radius == 0:
7 return 0;
8
9 case Square s:
10 return s.Side * s.Side;
11 case Circle c:
12 return c.Radius * c.Radius * Math.PI;
13 default:
14 throw new ArgumentException(
15 message: "shape is not a recognized shape",
16 paramName: nameof(shape));
17 }
18}
引发表达式
这个主要是针对 throw 关键字的增强，当我看到微软的文档的时候，我突然意识到，这个语法其实我用了很久啦！
1//场景A：条件运算符
2string arg = args.Length >= 1 ? args[0] :
3 throw new ArgumentException("You must supply an argument");
4//场景B：Null合并运算符
5public string Name
6{
7 get => name;
8 set => name = value ??
9 throw new ArgumentNullException(
10 paramName: nameof(value),
11 message: "Name cannot be null");
12}
13//场景C：Lambda表达式
14DateTime ToDateTime(IFormatProvider provider) =>
15 throw new InvalidCastException("Conversion to a DateTime is not supported.");
以上，就是 C# 7.0 中我个人比较喜欢的语法特性。需要了解所有 C# 7.0 语法特性的小伙伴们，则可以参考这里：C# 7.0 - C# 7.3 中的新增功能。
C# 8.0
在 C# 8.0 中，我个人比较喜欢的特性主要有以下几个：默认接口方法、异步流、索引和范围。
默认接口方法
关于这个，我觉得有点多此一举，如果一定要有一个默认行为，那你用继承来实现不就好啦，接口本来就是用来实现的啊摔！
1public class ChineseSayHello : ISayHello
2{
3 public string Who { get; set; }
4}
5
6public interface ISayHello
7{
8 private const string DefaultPersopn = "Anumouse";
9 string Who { get; set; }
10 void SayHello()
11 {
12 Who = DefaultPersopn;
13 Console.WriteLine($"Hello, {Who}");
14 }
15 }
在上面这个例子里，ChineseSayHello没有实现SayHello()方法不影响编译，因为ISayHello有默认实现，可正因为如此，SayHello()方法属于ISayHello，不属于ChineseSayHello：
1//正确，可以编译
2var sayHello = new ChineseSayHello() as ISayHello;
3sayHello.SayHello();
4//错误，无法编译
5 var sayHello = new ChineseSayHello();
6sayHello.SayHello();
异步流
该特性可以看作是IEnumerable<T>的一个延伸，即IAsyncEnumerable<T>，主要有下面三个属性：
- 它是用 async 修饰符声明的。
- 它将返回 IAsyncEnumerable。
- 该方法包含用于在异步流中返回连续元素的
yield return语句。
下面是一个来自微软官方的基本示例：
1//生成异步流
2public static async System.Collections.Generic.IAsyncEnumerable<int> GenerateSequence()
3{
4 for (int i = 0; i < 20; i++)
5 {
6 await Task.Delay(100);
7 yield return i;
8 }
9}
10//枚举异步流
11await foreach (var number in GenerateSequence())
12{
13 Console.WriteLine(number);
14}
和异步流相关的一个概念是：异步可释放，即 System.IAsyncDisposable，这个可以参考：实现 DisposeAsync 方法。
索引和范围
关于这个，我们换一种说法，可能大家就能接受啦！是什么呢？答案是：切片。切片语法博主经常在 Python 中使用，想不到有生之年居然可以在 C# 里用到这个语法。不过，这个语法糖怎么看都不甜啊，因为没那味儿！
1var words = new string[]
2{
3 // index from start index from end
4 "The", // 0 ^9
5 "quick", // 1 ^8
6 "brown", // 2 ^7
7 "fox", // 3 ^6
8 "jumped", // 4 ^5
9 "over", // 5 ^4
10 "the", // 6 ^3
11 "lazy", // 7 ^2
12 "dog" // 8 ^1
13};
14//取最后一个元素
15Console.WriteLine($"The last word is {words[^1]}");
16//获取第一个元素到第三个元素
17var quickBrownFox = words[1..4];
18//获取倒数第一个元素到倒数第二个元素
19var lazyDog = words[^2..^0];
20//获取全部元素
21var all = words[..];
22//获取开始到第三个元素
23var firstPhrase = words[..4];
24//获取结束到倒数第二个元素
25var lastPhrase = words[6..];
看起来这些东西在 Python 里都有啊，到底是哪里除了问题呢？我觉得更多的是符号上的不同吧， ^ 这个符号除了表示指数的意思以外，还有按位进行异或运算的意思，所以，这个语法糖加进来以后就会显得相当混乱，而 .. 这个符号显然没有 : 写起来方便啊，所以，虽然 C# 从 C# 8.0 开始有了切片语法，可这不是我想要的切片语法啊！
以上，就是 C# 8.0 中我个人比较喜欢的语法特性。需要了解所有 C# 8.0 语法特性的小伙伴们，则可以参考这里：C# 8.0 中的新增功能。
C# 9.0
在 C# 9.0 中，我个人比较喜欢的特性主要有以下几个：Record、顶级语句、模式匹配增强。
Record
record 是 C# 9.0 中提供的一个新的关键字，地位上等同于 class 和 struct，中文翻译为：记录类型。这是一种引用类型，它提供合成方法来提供值语义，从而实现相等性。 默认情况下，记录是不可变的。简而言之，record 是不可变的引用类型。你可能会说，我们为什么要搞这么一个类型出来呢？难道 class 不香吗？
我觉得如果要回答这个问题，可以借鉴 DDD 中的实体 和 值对象这两个概念。实体 通常都有一个唯一的标识并且在整个生命周期中具有连续性，这一类角色通过 class 来实现一直都工作得很好。例如，每一个 User 都会有一个唯一的UserId ，我们使用 UserId 来判断其相等性。而 值对象 则是指那些没有唯一的标识、不可变的、通过属性来判断相等性。例如，我们有一个地址 Address，它由省、市、区、县和详细地址组成，那么，问题来了，如果两个 Address 的省、市、区、县和详细地址都相同，这两个 Address 是不是同一个地址呢？常识告诉我们：不会，因为它们是不同的实例。
这就是 record 出现的原因，对于上面的这个问题，我们可以来解决：
1record Address
2{
3 public string Province { get; set; }
4 public string City { get; set; }
5 public string District { get; set; }
6 public string County { get; set; }
7}
8
9var addr1 = new Address() { Province = "陕西省", City = "西安市", District = "雁塔区" };
10var addr2 = new Address() { Province = "陕西省", City = "西安市", District = "雁塔区" };
11Console.WriteLine($"addr1 == addr2：{addr1 == addr2}");
想想以前我们是怎么做的呢？是不是要写类似下面这样的代码：
1if (addr1.Province == addr2.Province && addr1.City == addr2.City) {
2 //属性太多啦，我就不一个一个地比较啦，懂得都懂
3}
所以，这就是 record 存在的意义。除此之外呢，这个关键字更多的是语法层面上的，实际上从编译出来的 IL 来看，它本质上依然是一个类，并且它是不可变的。定义记录类型时，编译器会合成其他几种方法：
- 基于值的相等性比较方法
- 替代 GetHashCode()
- 复制和克隆成员
- PrintMembers 和 ToString()
那么，你可能还会有疑问，假如我定义了两个不同的记录类型，它们都拥有相同的属性成员，如果按值相等来判断的话，岂不是这两个不同的记录类型变成相同的了？这么重要的问题，微软怎么可能没有想到呢？编译器会合成一个 EqualityContract 属性，该属性返回与记录类型匹配的 Type 对象。在这里，微软再一次发挥了元组的威力，对于上面定义的地址，我们可以继续使用解构语法：
1(province, city, district, county) = addr1;
当然，我相信哪怕到2090年，这个世界上依然会有“杠精”：你说这玩意儿不能变？我就想变怎么办？答案是使用with语法：
1public record Person
2{
3 public string LastName { get; }
4 public string FirstName { get; }
5
6 public Person(string first, string last) => (FirstName, LastName) = (first, last);
7}
8
9var person = new Person("Bill", "Wagner");
10Person brother = person with { FirstName = "Paul" }; // 修改FirstName的副本
11Person clone = person with { }; // 空集副本
好了，关于记录类型就先为大家介绍到这里，更详细的说明可以参考这里：使用记录类型。
顶级语句
顶级语句，这个又是一个听起来非常模糊的概念对不对？ 大家可以看一下这篇文章：26 种不同的编程语言的 “Hello World” 程序。怎么样，在众多解释型的语言中，C#、Java 甚至 C++ 的 “Hello World” 是不是都看起来有一点臃肿？
好了，现在可以梦想成真啦！
1using System;
2
3Console.WriteLine("Hello World!");
如果觉得这样还显得臃肿，可以省略 using 部分：
1System.Console.WriteLine("Hello World!");
当然啦，一个项目里显然只能有一个文件可以使用顶级语句，你可以理解为这些代码运行在一个看不见的Main()方法中，而Main()方法显然只能有一个，相比下来，Python 就自由多啦，不过if __name__ == '__main__'的老梗就不再这里展开啦！
模式匹配增强
感觉微软在模式匹配的道路上越走越远啊，说好的语法糖呢？这简直是毒药，7.0 里面眼花缭乱的switch都还没学会呢！
1public static bool IsLetter(this char c) =>
2 c is >= 'a' and <= 'z' or >= 'A' and <= 'Z';
3
4public static bool IsLetterOrSeparator(this char c) =>
5 c is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z') or '.' or ',';
6
7if (e is not null)
8{
9 // ...
10}
以上，就是 C# 9.0 中我个人比较喜欢的语法特性。需要了解所有 C# 9.0 语法特性的小伙伴们，则可以参考这里：C# 9.0 中的新增功能。