C# 11 中的新增功能

09/06/2022 02:15:45 | China Standard Time

这篇文章将会列出 C# 11 中带来的 12 个新的功能。C# 11 将于 2022 年 11 月与 .NET 7 一起发布，你可以更新 Visual Studio 2022（17.3.0 或更高版本）或下载最新的 .NET 7 SDK 来获取这些功能。

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/9e01f47e-a4cf-46d9-bd9a-4775ff18cc77.jpg)

# Required Members

C# 11 引入了对属性和字段的新修饰符，以强制构造函数和调用方初始化这些值。如果没有初始化这些对象将会收到编译错误。

```csharp
// Initializations with required properties - valid
var p1 = new Person { Name = "Oleg", Surname = "Kyrylchuk" };
Person p2 = new("Oleg", "Kyrylchuk");

// Initializations with missing required properties - compilation error
var p3 = new Person { Name = "Oleg" };
Person p4 = new();

public class Person
{
	public Guid Id { get; set; } = Guid.NewGuid();
	public required string Name { get; set; }
	public required string Surname { get; set; }
}
```

如果构造函数有多个参数，则应在构造函数上添加 `SetsRequiredMembers` 特性，该特性将初始化所有 require 的成员。

```csharp
public class Person
{
	public Person() { }

	[SetsRequiredMembers]
	public Person(string name, string surname)
	{
		Name = name;
		Surname = surname;
	}

	public Guid Id { get; set; } = Guid.NewGuid();
	public required string Name { get; set; }
	public required string Surname { get; set; }
}
```

# Raw String Literals

C# 11 引入了原始字符串文本。它允许包含任意文本而不进行转义，并且允许换行。

```csharp
string name = "Oleg", surname = "Kyrylchuk";

string jsonString = 
	$$"""
	{
		"Name": {{name}},
		"Surname": {{surname}}
	}
	""";

Console.WriteLine(jsonString);
```

# UTF-8 String Literals

C# 11 引入了 UTF-8 字符串文本。它只允许将 UTF-8 字符转换为其字节表示形式。转换在编译时完成，没有额外开销。

```csharp
// C# 10
byte[] array = Encoding.UTF8.GetBytes("Hello World");

// C# 11
byte[] array = "Hello World";
```

# List Patterns

C# 11 引入了列表模式匹配。

模式匹配数组或列表中的元素序列。可以将列表模式与任何模式一起使用，包括常量、类型、属性和关系模式。

```csharp
var numbers = new[] { 1, 2, 3, 4 };

// List and constant patterns
Console.WriteLine(numbers is [1, 2, 3, 4]); // True
Console.WriteLine(numbers is [1, 2, 4]);    // False

// List and discard patterns
Console.WriteLine(numbers is [_, 2, _, 4]); // True
Console.WriteLine(numbers is [.., 3, _]);   // True

// List and logical patterns
Console.WriteLine(numbers is [_, >= 2, _, _]); // True
```

# Newlines in String Interpolation Expressions

C# 11 允许在字符串插值中换行。

它允许在 { } 之间添加任何有效 C# 代码，包括换行符，以提高可读性。

在插值中使用较长的 C# 表达式（如模式匹配 switch 表达式或 LINQ 查询）时，此功能非常有用。

```csharp
// switch expression in string interpolation
int month = 5;
string season = $"The season is {month switch
{
	1 or 2 or 12 => "winter",
	> 2 and < 6 => "spring",
	> 5 and < 9 => "summer",
	> 8 and < 12 => "autumn",
	_ => "unknown. Wrong month number",
}}.";

Console.WriteLine(season);
// The season is spring.

// LINQ query in string interpolation
int[] numbers = new int[] { 1, 2, 3, 4, 5, 6 };
string message = $"The reversed even values of 
	{nameof(numbers)} 
	are 
	{string.Join(", ", numbers.Where(n => n % 2 == 0).Reverse())}.";

Console.WriteLine(message);
// The reversed even values of numbers are 6, 4, 2.
```

# Auto-default Structs

C# 11 编译器将自动初始化结构中未初始化的任何字段或属性。

下面的代码无法在以前版本的 C# 中编译。

```csharp
struct Person
{
	public Person(string name)
	{
		Name = name;
	}

	public string Name { get; set; }
	public int Age { get; set; }
}
```

# Pattern Match on a Constant String `Span<char>`

C# 11 允许在常量字符串 `Span<char>` 和 `ReadOnlySpan<char>` 上进行模式匹配。

```csharp
ReadOnlySpan<char> str = "Oleg".AsSpan();

if (str is "Oleg")
{
	Console.WriteLine("Hey, Oleg");
}
```

# Generic Attributes

在之前的 C# 中，如果要将类型传递给特性，可以使用 `typeof` 表达式，但没有办法限制传递的类型。

C# 11 中允许对传递的类型进行限制。

```csharp
class MyType { }

class GenericAttribute<T> : Attribute where T : MyType
{
	private T _type;
}

[Generic<MyType>]
class MyClass { }
```

# Extended Scope `nameof`

C# 11 扩展了表达式 `nameof` 的范围。

可以在方法或参数声明的属性中指定方法参数的名称。

此功能可用于添加代码分析特性。

```csharp
public class MyAttr : Attribute
{
	private readonly string _paramName;
	public MyAttr(string paramName)
	{
		_paramName = paramName;
	}
}

public class MyClass
{
	[MyAttr(nameof(param))]
	public void Method(int param, [MyAttr(nameof(param))] int anotherParam) { }
}
```

# An Unsigned Right-shift Operator

C# 11 引入了一个无符号的右移运算符。`>>>`

```csharp
int n = -32;
Console.WriteLine($"Before shift: bin = {Convert.ToString(n, 2),32}, dec = {n}");

int a = n >> 2;
Console.WriteLine($"After     >>: bin = {Convert.ToString(a, 2),32}, dec = {a}");

int b = n >>> 2;
Console.WriteLine($"After    >>>: bin = {Convert.ToString(b, 2),32}, dec = {b}");

// Output:
// Before shift: bin = 11111111111111111111111111100000, dec = -32
// After     >>: bin = 11111111111111111111111111111000, dec = -8
// After    >>>: bin =   111111111111111111111111111000, dec = 1073741816
```

# Static Abstract Members in Interfaces

C# 11 在接口中引入了静态抽象成员。

可以在接口中添加静态抽象成员，用来定义包含重载运算符、其他静态成员和静态属性的接口。

```csharp
public interface IAdditionOperator<TSelf, TOther, TResult> where TSelf : IAdditionOperator<TSelf, TOther, TResult>
{
	static abstract TResult operator +(TSelf left, TOther right);
}
```

# Generic Math

C# 11 中新增泛型类型使用运算符的能力。您可以在[官方博客](https://devblogs.microsoft.com/dotnet/preview-features-in-net-6-generic-math/)中了解更多。

```csharp
Point p1 = new() { X = 10, Y = 5 };
Point p2 = new() { X = 5, Y = 7 };

Point p3 = p1 + p2;
Point p4 = p1 - p2;
Console.WriteLine(p3);
Console.WriteLine(p4);

public record Point : IAdditionOperators<Point, Point, Point>, ISubtractionOperators<Point, Point, Point>
{
	public int X { get; set; }
	public int Y { get; set; }

	public static Point operator +(Point left, Point right)
	{
		return left with { X = left.X + right.X, Y = left.Y + right.Y };
	}

	public static Point operator -(Point left, Point right) 
	{
		return left with { X = left.X - right.X, Y = left.Y - right.Y };
	}

	public override string ToString() => $"X: {X}; Y: {Y}";
}
```

kulabukhova-0ryg5@myrambler.ru 2025/12/08 05:12

pavlov-9ao9i@rambler.ua 2025/12/17 17:12