C# 9.0 添加和增强的功能【基础篇】

阅读目录

一、记录（record）

C# 9.0 引入了记录类型。可使用 record 关键字定义一个引用类型，以最简的方式创建不可变类型。这种类型是线程安全的，不需要进行线程同步，非常适合并行计算的数据共享。它减少了更新对象会引起各种bug的风险，更为安全。System.DateTime 和 string 也是不可变类型非常经典的代表。

与类不同的是，它是基于值相等而不是唯一的标识符--对象的引用。

通过使用位置参数或标准属性语法，可以创建具有不可变属性的记录类型，整个对象都是不可变的，且行为像一个值。

优点：

1）在构造不可变的数据结构时，它的语法简单易用；

2）record 为引用类型，不用像值类型在传递时需要内存分配，还可整体拷贝；

3）构造函数和结构函数为一体的、简化的位置记录；

4）有力的相等性支持 —— 重写了 Equals(object), IEquatable, 和 GetHashCode() 这些基本方法。

record 类型可以定义为可变的，也可以是不可变的。

	// 没有 set 访问器，创建后不可更改，叫不可变类型
	public record Person
	{
	// 要支持用对象初始化器进行初始化，则在属性中使用 init 关键字
	// 或者以构造函数的方式
	public string? FirstName { get; init; }
	public string? LastName { get; init; }
	}
	// 可变类型的 record
	// 因为有 set 访问器，所以它支持用对象初始化器进行初始化
	public record Person
	{
	public string? FirstName { get; set; }
	public string? LastName { get; set; }
	}

记录（record）和类一样，在面向对象方面，支持继承，多态等所有特性。除过前面提到的 record 专有的特性，其他语法写法跟类也是一样。同其他类型一样，record 的基类依然是 object。

注意：1）记录只能从记录继承，不能从类继承，也不能被任何类继承； 2）record 不能定义为 static 的，但是可以有 static 成员。

从本质上来讲，record 仍然是一个类，但是关键字 record 赋予这个类额外的几个像值的行为：

1）基于值相等性的比较方法，如 Equals,==,!=,EqualityContract 等； 2）重写 GetHashCode()； 3）拷贝和克隆成员； 4）PrintMembers 和 ToString() 方法。

应用场景：

1）用于 web api 返回的数据，通常作为一种一次性的传输型数据，不需要是可变的，因此适合使用 record；2）作为不可变数据类型 record 对于并行计算和多线程之间的数据共享非常适合，安全可靠；3）record 本身的不可变性和 ToString 的数据内容的输出，不需要人工编写很多代码，就适合进行日志处理；4）其他涉及到有大量基于值类型比较和复制的场景，也是 record 的常用的使用场景。

with 表达式

当使用不可变的数据时，一个常见的模式是从现存的值创建新值来呈现一个新状态。

例如，如果 Person 打算改变他的姓氏（last name），我们就需要通过拷贝原来数据，并赋予一个不同的 last name 值来呈现一个新 Person。这种技术被称为非破坏性改变。作为描绘随时间变化的 person，record 呈现了一个特定时间的 person 的状态。为了帮助进行这种类型的编程，针对 records 就提出了 with 表达式，用于拷贝原有对象，并对特定属性进行修改

	// 修改特定属性后复制给新的 record
	var person = new Person { FirstName = "Mads", LastName = "Nielsen" };
	var otherPerson = person with { LastName = "Torgersen" };
	// 只是进行拷贝，不需要修改属性，那么无须指定任何属性修改
	Person clone = person with { };

with 表达式使用初始化语法来说明新对象在哪里与原有对象不同。with 表达式实际上是拷贝原来对象的整个状态值到新对象，然后根据对象初始化器来改变指定值。这意味着属性必须有 init 或者 set 访问器，才能用 with 表达式进行更改。

注意：1）with 表达式左边操作数必须为 record 类型； 2）record 的引用类型成员，在拷贝的时候，只是将所指实例的引用进行了拷贝。

record 参考：C# 9.0新特性详解系列之五：记录(record)和with表达式

	// 以下结构定义了天气观察结构
	public struct WeatherObservation
	{
	public DateTime RecordedAt { get; init; }
	public decimal TemperatureInCelsius { get; init; }
	public decimal PressureInMillibars { get; init; }
	public override string ToString() =>
	$"At {RecordedAt:h:mm tt} on {RecordedAt:M/d/yyyy}: " +
	$"Temp = {TemperatureInCelsius}, with {PressureInMillibars} pressure";
	}
	// 调用方可使用属性初始化表达式语法来设置值，同时仍保留不变性
	var now = new WeatherObservation
	{
	RecordedAt = DateTime.Now,
	TemperatureInCelsius = 20,
	PressureInMillibars = 998.0m
	};
	//初始化后尝试更改观察值会导致编译器错误
	// Error! CS8852.
	now.TemperatureInCelsius = 18;

	using System;
	namespace HelloWorld
	{
	class Program
	{
	static void Main(string[] args)
	{
	Console.WriteLine("Hello World!");
	}
	}
	}
	// 只有一行代码执行所有操作，借助顶级语句
	// 可使用 using 指令和执行操作的一行替换所有样本
	using System;
	Console.WriteLine("Hello World!");
	// 如果需要单行程序，可删除 using 指令，并使用完全限定的类型名称
	System.Console.WriteLine("Hello World!");

	// 类型模式，一个类型模式需要声明一个标识符
	void M(object o1, object o2)
	{
	var t = (o1, o2);
	if (t is (int, string)) {} // 判断 o1、o2 是 int、string 类型
	switch (o1) {
	case int: break; // 判断 o1 是 int
	case System.String: break; // 判断 o1 是 string
	}
	}
	// 关系模式，关系运算符<,<=等对应的模式
	DeliveryTruck t when t.GrossWeightClass switch
	{
	> 5000 => 10.00m + 5.00m,
	< 3000 => 10.00m - 2.00m,
	_ => 10.00m,
	},
	// 逻辑模式，用逻辑操作符and，or 和not将模式进行组合
	DeliveryTruck t when t.GrossWeightClass switch
	{
	< 3000 => 10.00m - 2.00m,
	>= 3000 and <= 5000 => 10.00m,
	> 5000 => 10.00m + 5.00m,
	},

	using System;
	namespace System.Runtime.CompilerServices
	{
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	public sealed class ModuleInitializerAttribute : Attribute { }
	}

	using System.Runtime.CompilerServices;
	class MyClass
	{
	[ModuleInitializer]
	internal static void Initializer()
	{ ... }
	}

	static class ModuleInit
	{
	static ModuleInit()
	{
	//先执行
	Console.WriteLine("ModuleInit静态构造函数 cctor");
	}
	[ModuleInitializer]
	internal static void Initializer()
	{
	//在静态构造函数执行后才执行
	Console.WriteLine("模块初始化器");
	}
	}

1 作为基类或接口	2 作为的接收方 member_access
3 作为 type 中的 object_creation_expression	4 作为 delegate_type 中的 delegate_creation_expression
5 作为 type 中的 is_expression ， catch_clause 或 type_pattern	6 作为 interface 完全限定的接口成员名称中的

	// 允许字段初始化，而不显示类型
	Dictionary<string, List<int>> field = new() { { "item1", new() { 1, 2, 3 } } };
	// 如果可从用法推断，则允许省略类型
	XmlReader.Create(reader, new() { IgnoreWhitespace = true });
	// 实例化对象，而不会对类型进行拼写检查
	private readonly static object s_syncObj = new();

	(int a, int b) t = new(1, 2); // "new" 是不必要的
	Action a = new(() => {}); // "new" 是不必要的
	(int a, int b) t = new(); // 可以，类似 (0, 0)
	Action a = new(); // 没有发现构造函数

	[SerializableAttribute]
	partial class Moon { }
	[ObsoleteAttribute]
	partial class Moon { }
	// 上边部分的两次声明，等同于以下声明
	[SerializableAttribute]
	[ObsoleteAttribute]
	class Moon { }

	partial class Earth : Planet, IRotate { }
	partial class Earth : IRevolve { }
	// 与下面声明等效
	class Earth : Planet, IRotate, IRevolve { }

	// 定义在 file1.cs
	partial void OnNameChanged();

	// 实现在 file2.cs
	partial void OnNameChanged()
	{
	// method body
	}

	// lambda 中需要获取 y，所以就有了意想不到的堆分配
	int y = 1;
	MyMethod(x => x + y);
	// 为了避免这种不必要和浪费内存的分配，可以在 lambda 上使用 static 关键词或变量上标注 const
	const int y = 1;
	MyMethod(static x => x + y);
	// 注：static 匿名函数不能访问封闭方法的局部变量和参数和 this 指针，但可以引用它的静态方法和常量

	// 通过两步标记，来避免多余的内存分配
	public class Demo
	{
	// 1/2 formattedText 上标记 const
	private const string formattedText = "{0} It was developed by Microsoft's Anders Hejlsberg in the year 2000.";
	void DisplayText(Func<string, string> func)
	{
	Console.WriteLine(func("C# is a popular programming language."));
	}
	public void Display()
	{
	// 2/2 lambda 上标记 static
	DisplayText(static text => string.Format(formattedText, text));
	Console.Read();
	}
	}
	class Program
	{
	static void Main(string[] args)
	{
	new Demo().Display();
	Console.Read();
	}
	}
	// 若没有今天加静态标识，则：
	// formattedText 变量会被 DisplayText 方法中的 func 所捕获，这也就意味着它会产生你意料之外的内存分配

	partial class ClassWithNestedClass
	{
	partial class NestedClass { }
	}
	partial class ClassWithNestedClass
	{
	partial class NestedClass { }
	}

	// 分部结构和接口示例
	partial interface ITest
	{
	void Interface_Test();
	}
	partial interface ITest
	{
	void Interface_Test2();
	}
	partial struct S1
	{
	void Struct_Test() { }
	}
	partial struct S1
	{
	void Struct_Test2() { }
	}

	public abstract class A
	{
	public abstract A? GetNewOne(A? val); // 固定类型 A?
	}
	public sealed class B : A
	{
	public override A? GetNewOne(A? val) => val as B; // 实现抽象方法时，仍要返回固定类型 A?
	}

	public static class Utils
	{
	public static IEnumerator<int> GetEnumerator(this int @this)
	{
	for (int i = 0, v = @this; i < 32; i++, v >>= 1)
	{
	if ((v & 1) != 0)
	{
	yield return i;
	}
	}
	}
	}
	// 于是我们就可以对 int 类型的值应用 foreach
	foreach (int offset in 17)
	{
	// ...
	}

	(_, _) => 0 ， (int _, int _) => 0 // lambda 表达式
	delegate(int _, int _) { return 0; } // 匿名方法

	public void Method()
	{
	var rng = new Random();
	Console.WriteLine(g());
	Console.WriteLine(g());
	Console.WriteLine(g());
	// Local function.
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	int g() => rng.Next(1, 100);
	}

	Console.WriteLine($"size of nint = {sizeof(nint)}");
	Console.WriteLine($"size of nuint = {sizeof(nuint)}");
	// output when run in a 64-bit process
	//size of nint = 8
	//size of nuint = 8
	// output when run in a 32-bit process
	//size of nint = 4
	//size of nuint = 4

	// 也可以通过静态 IntPtr.Size 和 UIntPtr.Size 属性获得等效的值。

	Console.WriteLine($"nint.MinValue = {nint.MinValue}");
	Console.WriteLine($"nint.MaxValue = {nint.MaxValue}");
	Console.WriteLine($"nuint.MinValue = {nuint.MinValue}");
	Console.WriteLine($"nuint.MaxValue = {nuint.MaxValue}");
	// output when run in a 64-bit process----
	//nint.MinValue = -9223372036854775808
	//nint.MaxValue = 9223372036854775807
	//nuint.MinValue = 0
	//nuint.MaxValue = 18446744073709551615
	// output when run in a 32-bit process----
	//nint.MinValue = -2147483648
	//nint.MaxValue = 2147483647
	//nuint.MinValue = 0
	//nuint.MaxValue = 4294967295

	unsafe
	{
	int arr[] = { 3, 8, 1, 6, 5, 4, 7, 2, 9 };
	delegate* managed<int, int, int> funcPtr = &compareTwoValue; // Here.
	bubbleSort(arr, funcPtr); // Pass the function pointer.
	}
	static int compareTwoValue(int a, int b) => a - b;
	static unsafe void bubbleSort(int* arr, delegate* managed<int, int, int> comparison)
	{
	for (int i = 0; i < arr.Length; i++)
	{
	for (int j = 0; j < arr.Length - 1 - i; j++)
	{
	if (comparison(arr[j], arr[j + 1]) >= 0)
	{
	int temp = arr[j];
	arr[j] = arr[j + 1];
	arr[j + 1] = temp;
	}
	}
	}
	}

	// 如果类型参数 T 替换为引用类型，则 T? 表示该引用类型的可以为 null 的实例
	var s1 = new string[0].FirstOrDefault(); // string? s1
	var s2 = new string?[0].FirstOrDefault(); // string? s2
	// 如果 T 用值类型替换，则 T? 表示的实例 T
	var i1 = new int[0].FirstOrDefault(); // int i1
	var i2 = new int?[0].FirstOrDefault(); // int? i2
	// 如果 T 使用批注类型替换 U? ，则 T? 表示批注的类型 U? 而不是 U??
	var u1 = new U[0].FirstOrDefault(); // U? u1
	var u2 = new U?[0].FirstOrDefault(); // U? u2
	// 如果 T 将替换为类型 U ，则 T? 表示 U? ，即使在上下文中也是如此 #nullable disable
	#nullable disable
	var u3 = new U[0].FirstOrDefault(); // U? u3
	// 对于返回值， T? 等效于 [MaybeNull]T ; 对于参数值， T? 等效于 [AllowNull]T
	// 在使用 c # 8 编译的程序集中重写或实现接口时，等效性非常重要
	public abstract class A
	{
	[return: MaybeNull] public abstract T F1<T>();
	public abstract void F2<T>([AllowNull] T t);
	}
	public class B : A
	{
	public override T? F1<T>() where T : default { ... } // matches A.F1<T>()
	public override void F2<T>(T? t) where T : default { ... } // matches A.F2<T>()
	}

漫思