C# on 纪伟的个人博客

.NET 新特性（六）：.NET 10（C# 14）最新 LTS

Wed, 27 May 2026 10:00:00 +0800

写在前面

本文是 .NET 新特性系列收官篇。.NET 10（2025-11）是当前最新的 LTS。C# 14 带来几个让人等了很久的特性：扩展成员（终于能扩展属性和静态成员）、field 关键字（访问自动属性的 backing field）、null 条件赋值。

运行时继续打磨，生产可用性进一步巩固。

一、版本概览

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


.NET 10
 发布：2025-11
 支持：LTS（3 年）
 C#：14
 定位：当前最新 LTS

 特点：
 ✓ 扩展成员（扩展属性/静态成员）
 ✓ field 关键字
 ✓ null 条件赋值
 ✓ 性能持续提升
 ✓ 新项目首选 LTS

二、C# 14 语言特性（重点）

2.1 扩展成员（extension members）⭐

等了很久的特性。以前只能写扩展方法，C# 14 终于能写扩展属性、扩展静态成员：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 以前（C# 3+）：只能扩展方法
public static class StringExtensions
{
 public static bool IsBlank(this string s) => string.IsNullOrWhiteSpace(s);
}

// C# 14：扩展属性（计算属性）
public static class StringExtensions
{
 extension(string s)
 {
 public bool IsBlank => string.IsNullOrWhiteSpace(s); // 扩展属性
 public string Reversed => new string(s.Reverse().ToArray());
 }
}

"abc".IsBlank; // false（像属性一样用）
"abc".Reversed; // "cba"

// 还能扩展静态成员
extension(string)
{
 public static string Empty2 => ""; // String.Empty2（静态）
}

1
2
3
4
5


意义：
 C# 3 的扩展方法解决了"给现有类型加方法"
 C# 14 终于补齐"加属性、加静态成员"
 统一了扩展的语法
 写流畅 API、DSL 更自然

2.2 field 关键字 ⭐

访问自动属性的 backing field（编译器生成的隐藏字段）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 以前：要么全用自动属性（无法加逻辑），要么手写字段
public class User
{
 private string _name = "";
 public string Name
 {
 get => _name;
 set => _name = string.IsNullOrWhiteSpace(value) ? "" : value;
 }
}

// C# 14：field 关键字，访问自动属性的 backing field
public class User
{
 public string Name { get; set => field = string.IsNullOrWhiteSpace(value) ? "" : value; } = "";
 // field 就是编译器生成的 backing field，无需手写 _name
}

// 还能在 get 里用
public int Discount
{
 get => field > 0 ? field : 0;
 set;
}

1
2
3


field 解决：
 自动属性要加一点逻辑时，不用退回手写字段
 保持自动属性的简洁 + 按需加逻辑

2.3 null 条件赋值 ⭐

1
2
3
4
5
6
7
8


// 以前：要先判断 null
if (user != null) user.Name = "new";

// C# 14：null 条件赋值
user?.Name = "new"; // user 非 null 才赋值

// 链式也行
config?.Database?.Timeout = 30; // 中间任意为 null 就跳过

2.4 其他

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// user-defined compound assignment（自定义复合赋值）
// 配合 operator+ 等，自定义 += 行为

// partial events / partial constructors（配合源生成器）
public partial class X
{
 public partial void OnLoad(); // partial 方法（已有）
 public partial event EventHandler? Saved; // C# 14：partial 事件
}

// nameof unbound generic
string n = nameof(List<>); // "List"（不用指定类型参数）

// 隐式 Span/ReadOnlySpan 转换
void TakeSpan(ReadOnlySpan<int> s) { }
TakeSpan([1, 2, 3]); // 隐式转换更自然

// lambda 加 params
Func<int, int> f = params (int x) => x; // lambda 参数加 params（少见）

三、运行时与性能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


.NET 10 性能持续打磨：
 ✓ JIT 改进（更多优化、向量化）
 ✓ NativeAOT 改进（更小体积、更快、更多兼容）
 ✓ Server GC 进一步调优
 ✓ 异步、Span 持续优化
 ✓ JIT for loops 改进

 亮点：
 PGO 进一步增强（基于实际运行更精准）
 AOT 生态扩大（更多库 AOT 友好）

四、BCL 改进

1
2
3
4
5
6
7
8


// JsonSerializerOptions.Web（Web 场景默认选项）
var opts = JsonSerializerOptions.Web; // camelCase、宽松、适合 API

// 集合改进（Frozen、新增 API）
// Numerics / TensorPrimitives 增强（AI 方向持续）
// Source Generator 支持 JSON 序列化完善

// HttpClient、配置等改进

五、ASP.NET Core 10

1
2
3
4
5


✓ 性能改进
✓ Blazor 改进
✓ OpenAPI 原生生成完善
✓ AOT 支持扩大
✓ 身份认证、授权改进

六、升级建议

1
2
3
4
5
6
7


.NET 10 是最新 LTS，新项目首选
从 8 升 10（同为 LTS）：
 ✓ 扩展成员、field、null 条件赋值（生产力）
 ✓ 性能
 ✓ AOT 改进

兼容性好，升级风险低

七、小结

.NET 10 是当前最新 LTS：

C# 14：扩展成员（属性/静态）、field 关键字、null 条件赋值、partial 事件、nameof 泛型、隐式 Span 转换
运行时：JIT/AOT/PGO 持续改进
BCL：JsonSerializerOptions.Web、AI 数值方向
ASP.NET Core：性能、Blazor、OpenAPI、AOT
定位：当前最新 LTS，新项目首选

系列总结

.NET 新特性六篇完结（5 → 10）：

1
2
3
4
5
6


.NET 5（C# 9） 统一开端 record、init、顶级语句、模式匹配
.NET 6（C# 10） 首个统一LTS 全局using、文件命名空间、record struct、Minimal API
.NET 7（C# 11） 表达力 原始字符串、列表模式、required、generic math
.NET 8（C# 12） 成熟LTS 主构造函数、集合表达式、NativeAOT、TimeProvider
.NET 9（C# 13） 精炼 params集合、Lock、HybridCache、TensorPrimitives
.NET 10（C# 14） 最新LTS 扩展成员、field、null条件赋值

选型建议：

新项目 / 生产 → 最新 LTS（.NET 10 或 8）
非 LTS（7/9）只用于尝鲜，不长期生产
升级收益看 LTS 版（6/8/10），ST 版（7/9）的语法特性只要项目支持就能用

演进脉络：

语言：减少样板、增强表达（record/init → 原始字符串 → 主构造 → 扩展成员）
运行时：性能 + AOT（分层编译 → PGO → NativeAOT）
BCL：现代化（DateOnly → TimeProvider → HybridCache）
方向：AI/数值（TensorPrimitives）、云原生（AOT、容器）

掌握 5→10 的演进，既能在新项目用最新特性，也能理解老代码的写法。

.NET 新特性（五）：.NET 9（C# 13）精炼优化

Tue, 26 May 2026 10:00:00 +0800

写在前面

本文是 .NET 新特性系列第五篇。.NET 9（2024-11）是非 LTS 版，重点是精炼和优化：params 集合（性能）、新 Lock 类型、HybridCache（统一缓存抽象）、Server GC 动态调谐。

语言上 C# 13 是小步改进，但运行时和 AI/数值方向投入很大（TensorPrimitives 等）。

一、版本概览

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


.NET 9
 发布：2024-11
 支持：非 LTS（标准支持 18 个月）
 C#：13
 定位：精炼优化、AI/数值方向布局

 特点：
 ✓ params 集合、新 Lock 类型
 ✓ HybridCache（统一缓存抽象）
 ✓ Server GC 动态调谐
 ✓ TensorPrimitives（AI/数值）

二、C# 13 语言特性

2.1 params 集合 ⭐

params 不再限于数组，支持任意集合类型（ReadOnlySpan、IEnumerable、List 等）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 以前：params 只能是数组（隐式 params object[] / int[]）
void Sum(params int[] nums) { }

// C# 13：params 支持任意集合类型
void Sum(params ReadOnlySpan<int> nums) { } // 栈分配，零 GC！
void Log(params IEnumerable<string> msgs) { }
void Build(params List<int> ns) { }

Sum(1, 2, 3); // 调用方式不变

// 关键收益：params + ReadOnlySpan = 零堆分配
// 高频变参方法（日志、拼接）受益

2.2 新 Lock 类型 ⭐

新的 System.Threading.Lock，比 lock(object) 更快更清晰：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 以前：lock 任意对象
private readonly object _lock = new();
lock (_lock) { /* 临界区 */ }

// C# 13：专用 Lock 类型
private readonly Lock _lock = new();
lock (_lock) { /* 临界区 */ } // lock(Lock) 走更快的路径

// Lock 还有 EnterScope() 等更现代的 API
using (_lock.EnterScope()) { /* 临界区 */ }

2.3 其他

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// \e 转义（ESC 字符，0x1B）
char esc = '\e'; // 以前要写 '' 或 (char)27

// ref struct 可作泛型类型参数（配合 allows ref struct 约束）
static T Process<T>(T t) where T : allows ref struct { }
Process<int>(1); // OK
Process<Span<int>>(span); // OK（ref struct 作泛型参数）

// method group 自然类型改进（重载解析更好）

// 部分属性（partial properties，配合源生成器）
public partial string Name { get; set; }

// 属性模式隐式（更简洁）
bool IsOrigin(Point p) => p is { X: 0 } && p is { Y: 0 };

三、运行时与性能

3.1 Server GC 动态调谐

1
2
3
4
5
6


.NET 8 的 Server GC 动态适应，.NET 9 进一步调谐：
 根据内存压力、工作负载自动调整
 Gen 0/1/2 阈值动态化
 容器内存限制感知更强

 效果：内存占用更稳定，长跑服务不易内存膨胀

3.2 性能改进

1
2
3
4


✓ JIT 改进（更多内联、常量折叠）
✓ AOT 改进（更多场景、更小体积）
✓ 异步改进
✓ 循环优化

四、BCL 改进（重头）

4.1 HybridCache（统一缓存抽象）⭐

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 以前：IDistributedCache / IMemoryCache 各自一套，要自己组装
// .NET 9：HybridCache 统一抽象（L1 内存 + L2 分布式）

builder.Services.AddHybridCache(options => {
 options.DefaultEntryOptions = new() { LocalCacheExpiration = TimeSpan.FromMinutes(10) };
});

public class UserService(HybridCache cache)
{
 public async Task<User> GetAsync(int id) =>
 // 先查 L1 内存，miss 查 L2 分布式，再 miss 调工厂
 await cache.GetOrCreateAsync($"user:{id}", async ct => await LoadFromDb(id), ct);
}

1
2
3
4
5


HybridCache 解决：
 L1（内存）+ L2（Redis）自动协同
 防缓存击穿（stampede 保护）
 统一 API，不再手写多级缓存
 （preview，后续版本完善）

4.2 OrderedDictionary（泛型版）

1
2
3
4
5


// 泛型有序字典（保持插入顺序）
var od = new OrderedDictionary<string, int>();
od["a"] = 1;
od["b"] = 2;
// 遍历按插入顺序

4.3 TensorPrimitives / Numerics（AI 方向）

1
2
3
4
5
6
7


// 张量基础运算（为 AI/ML 优化）
using System.Numerics.Tensors;
TensorPrimitives.Add(span1, span2, resultSpan); // 向量加
TensorPrimitives.Dot(a, b); // 点积

// 配合 generic math（INumber<T>），数值计算更通用
// .NET 9 加大 AI/数值投入，为 ML.NET、ONNX 提供基础

4.4 其他

1
2
3
4


// System.Text.Json：IndentCharacter/Size（缩进控制）、required 成员
// Span 系列改进（更多 API）
// TimeZoneInfo 改进
// SearchValues 增强

五、ASP.NET Core 9

1
2
3
4


✓ 静态资产优化（更好的静态资源交付、压缩、缓存）
✓ OpenAPI 原生生成（Microsoft.OpenApi，轻量）
✓ Blazor 改进（重新连接体验、静态 SSR）
✓ 路由改进（TypedResults 增强）

六、升级建议

1
2
3
4
5
6
7


.NET 9 非 LTS，生产建议用 8/10（LTS）
但值得体验：
 ✓ params ReadOnlySpan（高频方法零分配）
 ✓ Lock 类型
 ✓ HybridCache（preview）

从 8 升 9 风险低，可评估；生产建议等 10（LTS）

七、小结

.NET 9 是精炼优化的一版：

C# 13：params 集合（+ ReadOnlySpan 零分配）、新 Lock 类型、\e、ref struct 作泛型参数、partial 属性
运行时：Server GC 动态调谐、JIT/AOT 改进
BCL：HybridCache（统一缓存）、OrderedDictionary 泛型、TensorPrimitives（AI 数值）、JSON 改进
ASP.NET Core：静态资产优化、原生 OpenAPI、Blazor
定位：非 LTS，AI/数值方向布局，缓存统一

下一篇讲 .NET 10（C# 14）：扩展成员、field 关键字——最新 LTS。

.NET 新特性（四）：.NET 8（C# 12）成熟与 NativeAOT

Mon, 25 May 2026 10:00:00 +0800

写在前面

本文是 .NET 新特性系列第四篇。.NET 8（2023-11）是当前最成熟的 LTS。三大亮点：主构造函数（C# 终于有）、集合表达式（统一初始化）、NativeAOT 正式发布（编译成原生代码，启动极快）。

加上 TimeProvider（可测试的时间）、Frozen 集合（极快只读）等，.NET 8 是目前生产首选。

一、版本概览

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


.NET 8
 发布：2023-11
 支持：LTS（3 年）
 C#：12
 定位：成熟、生产首选 LTS

 亮点：
 ✓ NativeAOT 正式发布
 ✓ 主构造函数、集合表达式
 ✓ TimeProvider（可测试的时间）
 ✓ Frozen 集合、性能大幅提升

二、C# 12 语言特性（重点）

2.1 主构造函数（primary constructors）⭐

类/结构体的构造参数直接成为类成员（C# 终于有，之前 VB / Record 有）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 旧：字段 + 构造函数赋值
public class UserService
{
 private readonly IUserRepo _repo;
 private readonly ILogger<UserService> _logger;
 public UserService(IUserRepo repo, ILogger<UserService> logger)
 {
 _repo = repo; _logger = logger;
 }
}

// 新（C# 12）：主构造函数，参数直接用
public class UserService(IUserRepo repo, ILogger<UserService> logger)
{
 public User Get(int id) => repo.Get(id); // 直接用 repo
}

// 配合 init-only / 全局可访问
public class Point(double x, double y)
{
 public double X => x; // 暴露为属性
 public double Y => y;
 public Point() : this(0, 0) { } // 链式调用其他构造
}

1
2
3


主构造函数大幅减少样板代码
 DI 注入、值传递场景特别爽
 注意：参数不是字段，要在用它的方法里捕获（或包成属性）

2.2 集合表达式（collection expressions）⭐

统一所有集合的初始化语法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 以前：不同集合不同初始化
int[] a = new[] { 1, 2, 3 };
List<int> b = new() { 1, 2, 3 };
IEnumerable<int> c = new List<int> { 1, 2, 3 };
Span<int> d = stackalloc int[] { 1, 2, 3 };
ImmutableArray<int> e = ImmutableArray.Create(1, 2, 3);

// 现在：统一用 [ ... ]
int[] a = [1, 2, 3];
List<int> b = [1, 2, 3];
IEnumerable<int> c = [1, 2, 3];
Span<int> d = [1, 2, 3];
ImmutableArray<int> e = [1, 2, 3];

// 展开（..）：合并集合
int[] all = [0, .. existingArray, .. otherList, 4];

1
2
3
4
5


集合表达式编译器按目标类型选择最优实现：
 Span → stackalloc（栈分配，零 GC）
 ImmutableArray → 直接构造
 List → List
 统一、简洁、高性能

2.3 using 别名任意类型

1
2
3
4
5
6
7
8


// 别名不只是命名空间/类，可以是元组、泛型
using Point = (int X, int Y);
using Dict = System.Collections.Generic.Dictionary<string, int>;

Point p = (1, 2);
Dict d = new();

// 元组别名让"轻量结构"更易用

2.4 ref readonly 参数

1
2
3
4


// in：按引用传，只读，防拷贝
// .NET 8：ref readonly 参数
void Process(ref readonly BigStruct data) { }
// 明确表达：引用传 + 只读（in 的语义，但更显式）

2.5 其他

1
2
3
4
5
6


// inline arrays（[InlineArray(N)] 固定大小数组，安全 + 快）
// lambda 默认参数
Func<int, int> f = (int x = 1) => x * 2;

// Interceptor（实验性，源生成器拦截方法调用，热重载基础）
// ref struct 放宽

三、运行时与性能

3.1 NativeAOT 正式发布 ⭐

1
2
3
4


# 编译成原生代码，无需 .NET 运行时
dotnet publish -c Release -r linux-x64 -p:PublishAot=true

# 输出单个原生可执行文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


NativeAOT 的意义：
 ✓ 启动极快（毫秒级，无 JIT）
 ✓ 内存占用小（无运行时）
 ✓ 单文件部署，无依赖
 ✓ 适合云函数、CLI、边缘、容器
 
 限制：
 ✗ 反射受限（需 trim / 显式标注）
 ✗ 动态加载程序集不支持
 ✗ 部分库不兼容

 ASP.NET Core 也部分支持 AOT（Minimal API）

3.2 Server GC 动态适应

1
2
3
4


.NET 8 Server GC 根据工作负载动态调整堆大小
 高负载 → 分配更多堆
 低负载 → 释放内存给系统
 容器环境特别友好（内存占用更可控）

3.3 性能改进

1
2
3
4
5


✓ JIT 改进（更多向量化、内联）
✓ async state machine 更小
✓ 字符串操作、Span 改进
✓ System.Text.Json 性能（已是 .NET 最快 JSON）
✓ AOT、PGO 持续优化

四、BCL 改进（重头）

4.1 TimeProvider（可测试的时间）⭐

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 以前：DateTime.Now 难测试（依赖真实时间）
// .NET 8：TimeProvider 抽象时间

public class OrderService(TimeProvider time)
{
 public bool IsExpired(Order o)
 => time.GetUtcNow() > o.ExpireTime;
}

// 生产用真实时间
new OrderService(TimeProvider.System);

// 测试用虚拟时间
var fake = new FakeTimeProvider();
fake.SetUtcNow(new DateTimeOffset(2026, 1, 1));
new OrderService(fake); // 可控测试

4.2 Frozen 集合 ⭐

1
2
3
4
5
6
7


// 构建后不可变，但读取极快（编译期优化）
var frozen = FrozenDictionary.CreateRange(data);
var set = FrozenSet.CreateRange(items);

frozen.TryGetValue(key, out var v); // 比普通 Dictionary 读还快

// 适用：启动时构建、之后只读的查找表（配置、枚举映射）

4.3 SearchValues

1
2
3


// 快速字符集合查找（向量化）
var digits = SearchValues.Create("0123456789");
int idx = "abc123".AsSpan().IndexOfAny(digits); // 3

4.4 System.Text.Json 多态

1
2
3
4
5


[JsonPolymorphic]
[JsonDerivedType(typeof(Dog), "dog")]
[JsonDerivedType(typeof(Cat), "cat")]
public abstract class Animal { }
// 序列化派生类带类型标识，反序列化还原正确类型

4.5 其他

1
2
3
4
5


Random.Shared.GetItems(arr, 5); // 随机取 N 个
Random.Shared.Shuffle(arr); // 洗牌
// KeyedDi（Keyed 服务，按 key 注入）
builder.Services.AddKeyedTransient<IRepo, SqlRepo>("sql");
// ConfigureContainer、Numerics 改进

五、ASP.NET Core 8

1
2
3
4
5
6


✓ Blazor United（Server + WebAssembly 混合渲染）
✓ Server GC 默认开启（模板默认）
✓ AOT 支持（Minimal API 可 AOT）
✓ 缓存、限流（来自 7）完善
✓ 身份认证改进、OpenAPI
✓ .NET Aspire（云原生开发框架，preview）

六、升级建议

1
2
3
4
5
6
7
8


.NET 8 是当前最稳的 LTS，强烈推荐生产使用

新项目直接 8（或更新的 LTS 10）
升级收益：
 ✓ NativeAOT（启动/内存）
 ✓ 主构造函数、集合表达式（生产力）
 ✓ TimeProvider（可测试）
 ✓ Frozen 集合、性能

七、小结

.NET 8 是成熟的 LTS：

C# 12：主构造函数、集合表达式、using 别名任意类型、ref readonly
运行时：NativeAOT 正式、Server GC 动态适应、性能大幅提升
BCL：TimeProvider（可测试时间）、Frozen 集合、SearchValues、JSON 多态、Keyed DI
ASP.NET Core：Blazor United、Server GC 默认、AOT
定位：生产首选 LTS

下一篇讲 .NET 9（C# 13）：params 集合、Lock 类型、HybridCache。

.NET 新特性（三）：.NET 7（C# 11）表达力提升

Sun, 24 May 2026 10:00:00 +0800

写在前面

本文是 .NET 新特性系列第三篇。.NET 7（2022-11）是非 LTS 版，但 C# 11 的表达力大幅提升：原始字符串、列表模式、required、generic math——这些让代码更简洁、更安全、更强大。

运行时方面，Dynamic PGO 默认开启，性能继续攀升。

一、版本概览

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


.NET 7
 发布：2022-11
 支持：非 LTS（标准支持 18 个月）
 C#：11
 定位：表达力提升 + 性能打磨

 特点：
 ✓ C# 11 语法大跃进（原始字符串、列表模式、required）
 ✓ Dynamic PGO 默认开启
 ✓ 限流、输出缓存等 ASP.NET Core 中间件

二、C# 11 语言特性（重点）

2.1 原始字符串字面量（raw string literals）⭐

三引号 """ 包裹，无需转义，跨多行，写正则/JSON/HTML 爽：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 不用转义引号、反斜杠
var json = """
{
 "name": "张三",
 "regex": "\\d+"
}
""";

// 插值用多个 $（$$ 表示字面 { 一个）
var json2 = $$"""
{
 "id": {{userId}}
}
""";

// 写正则特别爽
var pattern = """\d{4}-\d{2}-\d{2}""";

2.2 列表模式（list patterns）⭐

匹配数组的结构和元素：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


int[] arr = { 1, 2, 3 };

// 匹配固定结构
_ = arr is [1, 2, 3]; // true
_ = arr is [1, .., 3]; // true（.. 匹配中间任意个）
_ = arr is [_, _, _]; // 长度 3

// 解构
if (arr is [var first, .. var middle, var last])
{
 // first=1, middle=[2], last=3
}

// switch
string Desc(int[] a) => a switch
{
 [] => "空",
 [single] => $"一个：{single}",
 [a, b] => $"两个：{a},{b}",
 [..] => "更多"
};

2.3 required 成员 ⭐

强制属性在构造时必须初始化：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class User
{
 public required int Id { get; init; } // 必须初始化
 public required string Name { get; init; } // 必须初始化
 public string? Email { get; init; }
}

var u = new User(); // ❌ 编译错误：缺 Id、Name
var u2 = new User { Id = 1, Name = "x" }; // ✅ 必填项已提供

// 比 [Required]（运行时验证）更强：编译期保证

2.4 generic math（静态抽象接口成员）⭐

接口可以有 static abstract 成员，让泛型数学运算成为可能：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 以前：无法对泛型 T 做 T + T（没有运算符约束）
// C# 11：通过 static abstract 接口

// 内置：INumber<T>, IAdditionOperators<T,T,T> 等
static T Sum<T>(params T[] values) where T : INumber<T>
{
 T sum = T.Zero;
 foreach (var v in values) sum += v; // 泛型类型也能 + 运算了！
 return sum;
}

Sum(1, 2, 3); // int: 6
Sum(1.5, 2.5); // double: 4.0

// 自己定义运算符接口
public interface IAddable<T> where T : IAddable<T>
{
 static abstract T operator +(T a, T b);
}

1
2
3
4


意义：
 以前泛型数学要写一堆重载 / 用 dynamic（性能差）
 现在 INumber<T> 约束，一套代码处理所有数值类型
 数值算法、向量运算极大受益

2.5 文件范围类型（file-scoped types）

类型只在当前文件可见：

1
2
3
4
5


file class InternalHelper { } // 只在本 .cs 文件可见

// 解决：
// 同一程序集多个文件想定义同名辅助类
// 或想限制类型可见性到单文件

2.6 UTF-8 字符串字面量

1
2
3
4


// u8 后缀：直接得到 UTF-8 字节（byte[]），不用 Encoding.GetBytes
byte[] bytes = "Hello"u8; // new byte[]{ 72, 101, ... }

// 网络协议、文件 IO 常需 UTF-8，省去运行时转换

2.7 其他

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// ref struct 放宽（可用作泛型参数，配合 Span）
// Span<char> 模式匹配
// checked 运算符（自定义 checked 版本）
// generic attributes（泛型特性）
public class MyAttr<T> : Attribute { }

// new() 在泛型约束
static T Create<T>() where T : new() => new T();

// nameof 作用域扩展

三、运行时与性能

3.1 Dynamic PGO 默认开启

1
2
3
4
5


.NET 6 引入 PGO 雏形，.NET 7 默认开启并增强：
 运行时收集热点方法的 profile（分支走向）
 重新编译时基于真实数据优化（内联、分支预测）
 
 实际应用性能提升 5~20%（无需改代码）

3.2 On-Stack Replacement (OSR)

1
2
3
4


方法正在执行中（长循环）也能从 tier 0 升级到 tier 1
 以前：方法要重新调用才优化
 现在：长时间运行的方法中途也能优化
 利好长任务、循环密集代码

3.3 AOT 改进

1
2


NativeAOT 实验性改进（.NET 8 才正式）
publish AOT 持续优化

3.4 其他

1
2
3
4


✓ JIT 改进（更多优化）
✓ 异步改进
✓ 反射性能（源生成器 代替）
✓ ARM64、LoongArch 支持

四、BCL 改进

4.1 CollectionsMarshal

1
2
3
4
5


// 拿到 Dictionary 内部值的引用（避免拷贝、可原地改）
ref int val = ref CollectionsMarshal.GetValueRefOrAddDefault(dict, key, out bool exists);
val += 1; // 直接改字典内值，无拷贝

// 高性能字典操作

4.2 其他

1
2
3
4
5


// Tar 类（读写 tar 归档）
// System.Text.Json：多态（polymorphic）部分支持
// Microsoft.Extensions.* 改进
// Random.Shared（线程安全随机）
// DateOnly/TimeOnly 增强

五、ASP.NET Core 7

5.1 速率限制中间件（Rate Limiter）

1
2
3
4
5
6


builder.Services.AddRateLimiter(o =>
{
 o.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(...);
 o.AddPolicy("per-ip", ctx => ...);
});
app.UseRateLimiter();

5.2 输出缓存（Output Cache）

1
2
3
4


builder.Services.AddOutputCache();
app.UseOutputCache();

app.MapGet("/hot", () => GetData()).CacheOutput(t => t.Expire(TimeSpan.FromMinutes(1)));

5.3 其他

1
2
3
4


✓ MTLS（双向 TLS）支持
✓ HTTP/3
✓ OpenAPI 改进
✓ SignalR / Blazor 改进

六、升级建议

1
2
3
4
5
6


.NET 7 已停止支持（2024-05），非 LTS 不适合长期生产
 → 升级到 8（LTS）

但 C# 11 特性（原始字符串、列表模式、required、generic math）：
 → 项目 ≥ 7 即可用，强烈推荐
 → 原始字符串 + 列表模式 + required 是日常高频特性

七、小结

.NET 7 是表达力提升的一版：

C# 11：原始字符串（"""）、列表模式、required、generic math（static abstract 接口）、file 类型、UTF-8 字面量
运行时：Dynamic PGO 默认开启、OSR
BCL：CollectionsMarshal、Tar、Random.Shared
ASP.NET Core：限流中间件、输出缓存、MTLS、HTTP/3
定位：非 LTS，但 C# 11 特性极有价值

下一篇讲 .NET 8（C# 12）：主构造函数、集合表达式、NativeAOT 正式——成熟的一代 LTS。

.NET 新特性（二）：.NET 6（C# 10）首个统一 LTS

Sat, 23 May 2026 10:00:00 +0800

写在前面

本文是 .NET 新特性系列第二篇。.NET 6（2021-11）是统一平台的首个 LTS——.NET 5 完成了品牌统一，.NET 6 让它稳定可生产，成为现代 .NET 真正的起点。

C# 10 重点是减少样板代码（全局 using、文件命名空间），运行时性能继续提升，ASP.NET Core 引入 Minimal APIs 改变了 API 开发方式。

一、版本概览

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


.NET 6
 发布：2021-11
 支持：LTS（3 年）
 C#：10
 定位：首个统一 LTS，现代 .NET 生产起点

 相比 .NET 5：
 ✓ LTS（企业敢用）
 ✓ 性能进一步打磨
 ✓ Minimal APIs（API 开发革命）
 ✓ .NET MAUI（跨平台 UI）正式版

二、C# 10 语言特性

2.1 全局 using（global using）

每个文件不用重复写 using，定义一次全项目生效：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 方式一：代码声明（放 GlobalUsings.cs）
global using System.Collections.Generic;
global using System.Linq;

// 方式二：.csproj 开启隐式 using
// <ImplicitUsings>enable</ImplicitUsings>
// 自动启用 System / System.Collections.Generic / System.Linq 等一组

// 之后所有文件不用再写这些 using
public class Service
{
 public List<int> Get() => new(); // 不用 using System.Collections.Generic
}

2.2 文件范围命名空间（file-scoped namespace）

整个文件一个命名空间时，少一层缩进：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 旧：块作用域，多一层缩进
namespace MyApp.Services
{
 public class UserService { }
}

// 新（C# 10）：分号结尾，少一层缩进
namespace MyApp.Services;

public class UserService { }

2.3 record struct（值类型记录）

C# 9 的 record 是引用类型。C# 10 增加 record struct（值类型）：

1
2
3
4
5
6
7
8
9


// record（引用类型）
public record Point(double X, double Y);

// record struct（值类型，栈分配，无 GC）
public readonly record struct Point(double X, double Y);

// 都有 record 特性：值相等、解构、with、ToString
var p1 = new Point(1, 2);
var p2 = p1 with { X = 10 }; // 非破坏性修改

2.4 结构体改进

1
2
3
4
5
6
7
8


// 结构体可有无参构造 + 字段初始化
public struct Temperature
{
 public double Value { get; init; } = 25.0;
 public Temperature() { }
}

// struct 也能用 with 表达式（C# 10）

2.5 const 插值字符串

1
2
3


const string App = "MyApp";
const string Version = "1.0";
const string FullName = $"{App} {Version}"; // C# 10：const 插值（组成部分都是常量时）

2.6 Lambda 改进

1
2
3
4
5
6
7
8


// 自然类型：编译器推断委托类型
var add = (int a, int b) => a + b; // 自动 Func<int,int,int>

// 显式声明返回类型
var parse = object (bool b) => b ? (object)1 : "x";

// Lambda 可加特性
var handler = [Description("处理")] (string s) => Process(s);

2.7 CallerArgumentExpression

参数为空时自动用另一个参数的表达式作异常信息：

1
2
3
4
5
6
7


public static void ThrowIfNull(object? arg,
 [CallerArgumentExpression(nameof(arg))] string? name = null)
{
 if (arg is null) throw new ArgumentNullException(name);
}

ThrowIfNull(user); // 抛：ArgumentNullException: user（自动带参数名）

2.8 其他

1
2
3
4
5
6
7
8


// record 的 ToString 可 sealed（防派生覆盖）
public record Derived(string Name) : Base(Name)
{
 public sealed override string ToString() => Name;
}

// 解构在 using 中、属性模式改进（嵌套简写）
static bool IsCenter(Point p) => p is { X: 0, Y: 0 };

三、运行时与性能

3.1 分层编译 + PGO 雏形

1
2
3
4
5
6
7


分层编译稳定：
 方法首次执行：快速低优化编译（tier 0）
 成为热点：重新高度优化（tier 1）
 兼顾启动速度与峰值性能

PGO（Profile-Guided Optimization）雏形：
 基于运行 profile 优化热点（.NET 6 引入，后续增强）

3.2 热重载（Hot Reload）

1
2
3
4


改代码不重启：
 ✓ ASP.NET Core 改控制器，浏览器刷新生效
 ✓ Blazor 热重载
 ✓ MAUI

3.3 Source Generator 成熟

1
2
3
4
5


编译时生成代码（代替反射）：
 ✓ 编译期生成，无运行时反射开销
 ✓ 类型安全
 ✓ AOT 友好
 应用：JSON 源生成、日志、配置绑定

3.4 其他性能

1
2
3
4


✓ Server GC 优化（多核）
✓ JIT 改进（内联、向量化）
✓ List<T> / Dictionary 优化
✓ async state machine 开销降低

四、BCL 新增

4.1 DateOnly / TimeOnly

1
2
3
4
5


DateOnly date = DateOnly.FromDateTime(DateTime.Now); // 2026-05-23
TimeOnly time = TimeOnly.FromDateTime(DateTime.Now); // 14:30:00

// 解决 DateTime 既表日期又表时间的混乱
// 生日用 DateOnly，打卡用 TimeOnly

4.2 PriorityQueue

1
2
3
4


var pq = new PriorityQueue<string, int>();
pq.Enqueue("普通", 1);
pq.Enqueue("紧急", 10);
pq.Dequeue(); // "紧急"（优先级最高）

4.3 PeriodicTimer

1
2
3


var timer = new PeriodicTimer(TimeSpan.FromSeconds(1));
while (await timer.WaitForNextTickAsync())
 DoWork(); // 每秒一次，异步友好

4.4 ThrowIf 辅助方法

1
2
3
4


ArgumentNullException.ThrowIfNull(arg);
ArgumentNullException.ThrowIfNullOrEmpty(str);
ArgumentOutOfRangeException.ThrowIfNegative(n);
// 内部用 CallerArgumentExpression，自动带参数名

4.5 其他

1
2


Channel<int> ch = Channel.CreateBounded<int>(100); // Channel 稳定
var chunks = Enumerable.Range(0, 10).Chunk(3); // 分块

五、ASP.NET Core 6

5.1 Minimal APIs

1
2
3
4
5
6
7
8
9


// Program.cs 几行写完 API，不用 Controller
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello");
app.MapGet("/users/{id}", (int id, IUserService svc) => svc.Get(id));
app.MapPost("/users", (User u) => Create(u));

app.Run();

5.2 其他

1
2
3
4


✓ 热重载（开发体验）
✓ Blazor 大幅改进
✓ .NET MAUI（跨平台 UI）
✓ 性能（HTTP/2、I/O）

六、升级建议

1
2
3
4
5
6
7


还在 .NET Core 3.1 / 5？
 → 升级到 6+（3.1 已停止支持）
 → 用 upgrade-assistant（微软迁移工具）

新项目：
 → 直接从 LTS（6/8/10）开始
 → 开启 ImplicitUsings、Nullable、分层编译

七、小结

.NET 6 是现代 .NET 的生产基石：

C# 10：全局 using、文件命名空间、record struct、结构体改进、lambda 自然类型、CallerArgumentExpression
运行时：分层编译、PGO 雏形、热重载、Source Generator 成熟
BCL：DateOnly/TimeOnly、PriorityQueue、PeriodicTimer、ThrowIf 辅助
ASP.NET Core：Minimal APIs、热重载、Blazor、MAUI
定位：首个统一 LTS，企业生产首选起点

下一篇讲 .NET 7（C# 11）：原始字符串、列表模式、required、generic math。

.NET 新特性（一）：.NET 5（C# 9）统一时代开端

Fri, 22 May 2026 10:00:00 +0800

写在前面

本文是 .NET 新特性系列第一篇。.NET 5（2020-11）是"统一 .NET"的第一代——从此去掉 “Core” 后缀，把原来的 .NET Framework + .NET Core + Xamarin 合并为一个平台。

虽然 .NET 5 是非 LTS 的过渡版本，但它带来的 C# 9 特性是划时代的：record、init、顶级语句、模式匹配增强——这些至今是日常代码的基石。从这版起，现代 C# 的面貌基本成型。

一、版本概览

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


.NET 5
 发布：2020-11
 支持：非 LTS（标准支持 18 个月）
 C#：9
 定位：统一时代开端

 历史意义：
 ✓ 去掉 "Core" 后缀，统一品牌
 ✓ Framework + Core + Xamarin 合并为一个 .NET
 ✓ 一个 BCL、一个运行时、一套工具链服务所有平台
 ✓ 跳过版本 4（避免和 .NET Framework 4.x 混淆）

二、C# 9 语言特性（重点）

2.1 record（记录类型）⭐

C# 9 最重要的特性。一行定义不可变、值相等的"数据类"：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 一行定义（编译器自动生成属性、构造、相等、ToString、解构）
public record User(int Id, string Name, string Email);

var u1 = new User(1, "张三", "z@test.com");
var u2 = new User(1, "张三", "z@test.com");

u1 == u2; // true（值相等，普通 class 是 false）
u1 with { Name = "李四" }; // with 表达式：复制并改一个字段
var (id, name, _) = u1; // 解构

// 传统 class 要手写一堆：构造、Equals、GetHashCode、ToString、Deconstruct
// record 一行搞定

1
2
3
4
5
6
7


record 的本质：
 基于值相等的引用类型（不可变）
 自动生成：属性、主构造、Equals/GetHashCode、ToString、Deconstruct
 支持 with（非破坏性修改）
 
 适用：DTO、值对象、消息、不可变数据
 C# 10 起还有 record struct（值类型版）

2.2 init 只读设置器 ⭐

对象初始化后不可修改：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class User
{
 public string Name { get; init; }
 public int Age { get; init; }
}

var u = new User { Name = "张三", Age = 25 }; // 初始化时设置
u.Age = 26; // ❌ 编译错误！init 后不可改

// 对比：
// get; set; — 任意读写（不安全）
// get; — 只读（只能在构造里赋值）
// get; init; — 初始化时写，之后只读（两全）

1
2
3
4


init 解决的问题：
 对象初始化器（new X { ... }）的灵活性
 + 创建后不可变的线程安全
 配合 record，是不可变数据建模的核心

2.3 顶级语句（top-level statements）⭐

Program.cs 不用写 class 和 Main，直接写代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// C# 9 之前：Program.cs
using System;
namespace MyApp
{
 class Program
 {
 static void Main(string[] args)
 {
 Console.WriteLine("Hello");
 }
 }
}

// C# 9：整个 Program.cs 就一行
System.Console.WriteLine("Hello");

// 还能用 async、args、返回值
var name = args.Length > 0 ? args[0] : "World";
Console.WriteLine($"Hello {name}");

1
2
3
4


顶级语句大幅简化小程序 / API 入口
 编译器自动包成 Main 方法
 ASP.NET Core 的 Minimal API 基于此（.NET 6）
 大型项目仍可用传统 Main

2.4 模式匹配增强

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// 关系模式（< > <= >=）
static string Grade(int score) => score switch
{
 >= 90 => "A",
 >= 80 => "B",
 >= 60 => "C",
 _ => "F"
};

// 逻辑组合（and / or / not）
static bool IsDigit(char c) => c is >= '0' and <= '9';
static bool IsLetter(char c) => c is >= 'a' and <= 'z' or >= 'A' and <= 'Z';

// not 模式
if (obj is not null) { } // 比 obj != null 更"模式化"

// 类型 + 条件组合
static decimal GetFee(object o) => o switch
{
 int n when n > 100 => 0.5m,
 string s => 1.0m,
 _ => 2.0m
};

2.5 target-typed new（目标类型 new）

省略类型名，由上下文推断：

1
2
3
4
5
6
7


// 上下文已知类型，new() 即可
Dictionary<string, List<int>> dict = new();
List<User> users = new();
Process(new User(1, "x")); // 参数类型已知，省略

// 对比旧写法：类型名写两遍
Dictionary<string, List<int>> dict = new Dictionary<string, List<int>>();

2.6 协变返回类型

重写方法可以返回更具体的派生类型：

1
2
3
4
5
6
7
8


class Animal
{
 public virtual Animal Clone() => new Animal();
}
class Dog : Animal
{
 public override Dog Clone() => new Dog(); // 返回 Dog（更具体），合法
}

2.7 本地大小整数（nint / nuint）

1
2
3
4
5


// nint = 平台相关的整数（32位系统是 int，64位是 long）
nint ptr = 123; // 64位系统上是 8 字节
nuint uptr = 456;

// 用于互操作、指针运算（和 IntPtr 对应）

2.8 其他

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 静态匿名 lambda（不捕获，可缓存）
Func<int, int> f = static x => x * 2;

// target-typed 条件表达式（两分支类型不同，但有公共目标类型）
var result = condition ? 1 : 1.5; // 推断为 double

// 函数指针（互操作，比 delegate 快）
delegate* unmanaged<int, int> fp;

// 模块初始化器（程序集加载时执行）
[ModuleInitializer]
internal static void Init() { /* 全局初始化 */ }

三、统一平台与运行时

3.1 统一 .NET

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


.NET 5 之前：
 .NET Framework（仅 Windows，老）
 .NET Core（跨平台，新）
 Xamarin/Mono（移动端）
 互不兼容，库要分别维护

.NET 5 之后：
 一个 .NET 运行所有平台
 一个 BCL（基础类库）
 一套 SDK / 工具链
 库只需写一次，到处跑

3.2 Single-file 发布

1
2
3
4


# 打成单个可执行文件
dotnet publish -c Release -r linux-x64 --self-contained false /p:PublishSingleFile=true

# 一个文件即可运行（无需装运行时，配合 self-contained）

3.3 Windows Runtime 支持

1
2


C#/WinRT：.NET 5 重新支持 Windows Runtime API（UWP、WinUI 互操作）
 在 .NET Core 3.x 被移除，5 重新引入（通过 CsWinRT）

3.4 性能改进

1
2
3
4
5


✓ GC 改进（Gen 0/1 更快）
✓ JIT 改进
✓ ARM64 优化
✓ 异步开销降低
✓ System.Text.Json 性能（追赶 Newtonsoft）

四、BCL 改进

1
2
3
4
5
6
7
8
9


// System.Text.Json 大幅增强（接近生产可用）
// 可空引用类型、记录、异步流

// Half（16位浮点）
Half h = 1.5f;

// System.Text.Json 可靠性提升（默认严格）

// StringComparer 改进、Regex 性能

五、升级建议

1
2
3
4
5
6


.NET 5 已停止支持（2022-05），不应再用于生产
 → 升级到 LTS（6/8/10）

但 C# 9 的特性（record、init、顶级语句）：
 → 仍是现代 C# 的核心，日常必用
 → 只要项目 ≥ C# 9（.NET 5+）就能用

六、小结

.NET 5 是统一时代的开端：

意义：去掉 Core 后缀，Framework+Core+Xamarin 统一
C# 9（划时代）：record、init、顶级语句、模式匹配（and/or/not、关系）、target-typed new、协变返回
平台：单一运行时/BCL/SDK，Single-file 发布，Windows Runtime
定位：非 LTS 过渡版，但 C# 9 特性奠定现代 C# 基础

下一篇讲 .NET 6（C# 10）：首个统一 LTS——全局 using、文件命名空间、record struct、Minimal API。