// 一个文件、一个 Program.cs，就是完整的 .NET 10 程序
// 顶级语句：没有 class、没有 Main，第一行就是可执行代码
using System.Net.Http.Json;

record Repo(string Name, int Stars);   // 一行定义不可变数据类型（含相等性/解构/ToString）

var http = new HttpClient();
var repos = await http.GetFromJsonAsync<Repo[]>(url) ?? [];   // async/await + JSON 反序列化都在 BCL 里

foreach (var r in repos.Where(r => r.Stars > 1000)
                     .OrderByDescending(r => r.Stars)
                     .Take(3))                       // LINQ：查询即代码
    Console.WriteLine($"{r.Name,-20} {r.Stars:N0}");   // 插值字符串 + 对齐 + 格式化

Host: Version: 10.0.10 ...        // ① 宿主：dotnet 这个可执行文件本身
.NET SDKs installed:              // ② 能不能编译，看这一段
  10.0.302
.NET runtimes installed:          // ③ 能不能运行，看这一段
  Microsoft.NETCore.App 10.0.10

# 三条命令验证装好了：版本、清单、能不能编译
$ dotnet --version          # 只打印当前生效的 SDK 版本，如 10.0.302
$ dotnet --list-sdks        # 装了哪些 SDK（空 = 只有运行时，编译不了）
$ dotnet --list-runtimes    # 装了哪些运行时

# 无管理员权限的装法（CI / 受限机器）
$ curl -sSL https://dot.net/v1/dotnet-install.sh | bash -s -- --channel 10.0 --install-dir ~/dotnet
$ export DOTNET_ROOT=~/dotnet && export PATH=$DOTNET_ROOT:$PATH

// Program.cs —— 顶级语句能做的全在这儿了
if (args.Length == 0)
{
    Console.Error.WriteLine("用法: greet <名字>");
    return 2;                       // 顶级语句里 return = 进程退出码
}

await Task.Delay(50);                   // 直接 await，编译器生成 async Main
Console.WriteLine(Greeter.Hi(args[0]));

return 0;

// 类型声明必须写在顶级语句之后
static class Greeter
{
    public static string Hi(string name) => $"你好，{name}！";
}

$ cat e5.cs
string? s = null;
Console.WriteLine(s.Length);

warning CS8602: 解引用可能出现空引用。      // 只是警告，照样编译通过
Unhandled exception. System.NullReferenceException:
   at Program.<Main>$(String[] args) in e5.cs:line 2

# 报错太长看不清？把诊断按等级过滤
$ dotnet build 2>&1 | grep -E "error|warning"

# 只想看错误、不看警告刷屏
$ dotnet build -warnaserror:nullable    # 只把可空相关的警告升级为错误
$ dotnet build -v quiet                 # 少打点 MSBuild 的日志

# 临时切回英文报错（跨平台通用）
$ DOTNET_CLI_UI_LANGUAGE=en dotnet build

struct PointS { public int X, Y; }
class  PointC { public int X, Y; }

var p1 = new PointS(1, 2);  var p2 = p1;  p2.X = 99;
var c1 = new PointC { X = 1 }; var c2 = c1;  c2.X = 99;

// 输出：
struct: p1.X=1  p2.X=99      // 改副本不影响原件
class : c1.X=99 c2.X=99      // 两个名字，同一个对象

// 传参也遵循同一套规则
void Bump(PointS s, PointC c)
{
    s.X++;      // 改的是副本，调用方看不见
    c.X++;      // 改的是同一个对象，调用方看得见
    c = new PointC();  // 但把参数变量重新指向新对象，调用方仍看不见！
}                       //（引用是按值传的——除非用 ref，见 05 章）

var s = new PointS { X = 1 };
var c = new PointC { X = 1 };
Bump(s, c);
Console.WriteLine($"{s.X} {c.X}");   // 1 2

0.1 + 0.2 == 0.3        // False —— 实际是 0.30000000000000004
0.1m + 0.2m == 0.3m     // True  —— decimal 是十进制的

int.MaxValue + 1        // -2147483648（默认 unchecked，静默环绕！）
checked(int.MaxValue+1) // 抛 OverflowException:
                        //   Arithmetic operation resulted in an overflow.

5 / 2 = 2               // 整数除法直接截断，不是四舍五入
5.0 / 2 = 2.5           // 只要有一边是浮点，结果就是浮点
-7 / 2 = -3  、 -7 % 2 = -1   // C# 的整除向零取整、余数随被除数符号

// 金额：decimal，且别忘了 m 后缀
decimal price = 19.99m;
decimal total = price * 3;              // 59.97 —— 精确

// 浮点比较用容差
static bool NearlyEqual(double a, double b, double eps = 1e-9)
    => Math.Abs(a - b) < eps;

// 数字分隔符与其它进制字面量（可读性）
int million  = 1_000_000;
int mask     = 0b1010_1010;
int color    = 0xFF_20_A0;

// 泛型数学（.NET 7+）：一个方法吃所有数值类型
static T Sum<T>(IEnumerable<T> xs) where T : INumber<T>
{
    T acc = T.Zero;
    foreach (var x in xs) acc += x;
    return acc;
}

var list = new List<string>();          // ① var：右边推左边
List<string> list2 = new();             // ② 目标类型 new（C# 9+）：左边推右边
var nums = new[] { 1, 2, 3 };           // 隐式类型数组 → int[]
int[] nums2 = [1, 2, 3];                // ③ 集合表达式（C# 12+），也能推 List/Span

// 目标类型推断让长泛型类型不用写两遍
Dictionary<string, List<int>> index = new();     // 比 var 更适合字段声明

// 集合表达式（C# 12+）：同一个语法，多种目标类型
int[] a = [1, 2, 3];
List<int> b = [1, 2, 3];
Span<int> c = [1, 2, 3];
int[] merged = [.. a, 99, .. b];        // 展开运算符 ..

// 常量与只读
public const string Scheme = "https";      // 编译期常量（会被内联）
public static readonly TimeSpan Timeout      // 运行期只读（不会内联）
    = TimeSpan.FromSeconds(30);            // const 写不了：不是编译期常量

int? age = null;

age ?? 18            // 空合并：左边是 null 就用右边 → 18
age ??= 20;          // 空合并赋值：只在为 null 时赋值
person?.Address?.City   // 空条件：链上任何一环是 null，整个表达式就是 null
list?[0]                // 索引器也有空条件写法
age!.Value              // null 宽容：「我保证不是 null」，仅关掉警告（07 章）

int? a = null;
a + 1        // null（不是 1！任何一边是 null，结果就是 null）
a > 0        // false
a <= 0       // 也是 false ← 两个都是 false，这不是普通的布尔取反
a == null    // true（相等比较是例外，正常工作）

// TryParse 模式：解析失败不抛异常，返回 bool + out
if (int.TryParse(input, out var n))
    Console.WriteLine(n * 2);
else
    Console.WriteLine("不是数字");

// 用可空值表达「解析失败」，能参与后续链式处理
static int? ParseOrNull(string? s)
    => int.TryParse(s, out var v) ? v : null;

int port = ParseOrNull(Environment.GetEnvironmentVariable("PORT")) ?? 8080;

// 模式匹配处理可空值最干净
string msg = ParseOrNull(input) switch
{
    null       => "没填",
    < 0       => "不能是负数",
    0          => "零",
    var v      => $"收到 {v}",
};

int.Parse("abc")      // 抛 FormatException:
                      //   The input string 'abc' was not in a correct format.（报错原文）
int.TryParse("abc", out var n)   // false，n = 0 —— 不抛异常
Convert.ToInt32(null)            // 0（把 null 当 0，很少是你想要的）

// 推荐：is 模式一步到位
if (value is string s && s.Length > 0)
    Console.WriteLine(s.ToUpperInvariant());

// 老写法（仍常见于旧代码）
var s2 = value as string;
if (s2 != null) { /* ... */ }

// 解析外部输入：TryParse + 显式区域
using System.Globalization;

if (decimal.TryParse(raw, NumberStyles.Number,
                       CultureInfo.InvariantCulture, out var amount))
    Console.WriteLine(amount);

// 自定义类型也能定义转换（谨慎使用）
public readonly record struct Celsius(double Degrees)
{
    public static implicit operator double(Celsius c) => c.Degrees;
    public static explicit operator Celsius(double d) => new(d);
}

object boxed = 0;
for (int i = 0; i < 100_000; i++) boxed = i;   // 每次循环装一次箱

// GC.GetTotalAllocatedBytes 分配 2,400,024 字节
// = 每个 int 24 字节（4 字节的 int，被包成了 24 字节的堆对象）

// 装箱看不出来，但 IL 里有 box 指令
object o = 42;                 // box —— 堆分配 24 字节
int back = (int)o;             // unbox.any —— 类型必须完全一致
// long wrong = (long)o;        // 运行期 InvalidCastException！拆箱不做数值转换

// 非泛型 vs 泛型
var old = new ArrayList();  old.Add(1);   // 装箱
var now = new List<int>();  now.Add(1);   // 不装箱

// 让 struct 免于装箱比较
public readonly struct Money(decimal v) : IEquatable<Money>
{
    public readonly decimal Value = v;
    public bool Equals(Money other) => Value == other.Value;   // 强类型重载，无装箱
    public override bool Equals(object? o) => o is Money m && Equals(m);
    public override int GetHashCode() => Value.GetHashCode();
}

string s = "hello";
s.ToUpper();            // 返回新字符串，s 自己没变！——新手最常见的一行废代码
s = s.ToUpper();        // 这样才行

s[0] = 'H';             // 编译错误：字符串索引器是只读的

string a = "he", b = "llo";
(a + b) == "hello"                      // True  —— == 比较内容
ReferenceEquals(a + b, "hello")         // False —— 运行期拼出来的是新对象
ReferenceEquals("hello", "hello")       // True  —— 字面量被驻留（intern）到同一个实例
(object)(a + b) == (object)"hello"      // False —— 转成 object 后 == 变回引用比较！

// 判空：三个方法，语义不同
string.IsNullOrEmpty(s)         // null 或 ""
string.IsNullOrWhiteSpace(s)    // null、"" 或全是空白 —— 校验用户输入用这个
s is { Length: > 0 }            // 模式匹配写法：非 null 且非空

// 常用操作全是「返回新的」
var t = "  Hello, World  ";
t.Trim()                       // "Hello, World"
t.Replace("World", "C#")        // "  Hello, C#  "
t.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries)
string.Join(" | ", ["a", "b", "c"])   // "a | b | c"
t.Contains("World", StringComparison.OrdinalIgnoreCase)

"普通\n换行"                      // 支持转义
@"C:\不转义\的路径"                // 逐字字符串：反斜杠不再是转义符
$"你好 {name}，共 {count} 条"      // 插值：把表达式直接嵌进去
"""
{ "json": "里面可以随便写引号和反斜杠" }
"""                              // 原始字符串（C# 11+）：所见即所得

$"{name,-20}"        // 左对齐、宽 20（负数=左对齐）
$"{price,10:N2}"     // 右对齐宽 10，千分位 + 两位小数 → 1,234.50
$"{ratio:P1}"        // 百分比 → 42.0%
$"{n:X}"             // 十六进制 → FF
$"{dt:yyyy-MM-dd}"   // 自定义日期格式
$"{dt:O}"            // 往返格式（ISO 8601）—— 存储与传输一律用它

// 原始字符串写 JSON：不用转义任何引号
var json = """
{
  "name": "Alice",
  "tags": ["a", "b"]
}
""";

// 原始字符串 + 插值（双 $ 让占位符变成 {{}}，花括号本身就不用转义了）
var tpl = $$"""
{ "user": "{{name}}", "level": {{level}} }
""";

// 对齐做表格输出
foreach (var (n, v) in rows)
    Console.WriteLine($"{n,-16}{v,12:N0}");

// 结构化日志：不要用插值！
logger.LogInformation("订单 {OrderId} 金额 {Amount}", id, amount);   // ✓
logger.LogInformation($"订单 {id} 金额 {amount}");                   // ✗ 丢字段

var sb = new StringBuilder();
for (int i = 0; i < 10_000; i++) sb.Append('x');      // 分配 33,176 字节

string s = "";
for (int i = 0; i < 10_000; i++) s += 'x';            // 分配 100,261,224 字节

// 差约 3000 倍 —— 用 GC.GetTotalAllocatedBytes 

// 循环拼接的正确姿势
var sb = new StringBuilder(capacity: 1024);   // 预估容量可再省几次扩容
foreach (var row in rows)
    sb.Append(row.Name).Append('\t').Append(row.Score).AppendLine();
string result = sb.ToString();

// 但这些场景别用 StringBuilder
var a = first + " " + last;                // 编译成一次 Concat
var b = string.Join(", ", names);           // 内部已优化
var c = $"{name} 共 {count} 条";             // 插值处理器

// 高性能场景：不产生中间字符串地构造（.NET 6+）
string masked = string.Create(card.Length, card, (span, src) =>
{
    src.AsSpan().CopyTo(span);
    span[..^4].Fill('*');                  // 只保留后四位
});

"👍".Length          // 2  —— 一个 emoji 占两个 char（代理对）
"中".Length          // 1

"a👍中" 的三种数法:
  .Length                        = 4   // UTF-16 码元数
  .EnumerateRunes().Count()      = 3   // Unicode 码点数（真正的"字符"数）
  Encoding.UTF8.GetByteCount(..) = 8   // UTF-8 字节数（a=1, 👍=4, 中=3）

using System.Text;
using System.Globalization;

var s = "a👍中";

// ✗ 按 char 遍历：emoji 会被拆成两个乱码
foreach (char c in s) Console.Write(c + "|");

// ✓ 按 Rune 遍历：每次拿到一个完整码点
foreach (Rune r in s.EnumerateRunes())
    Console.WriteLine($"{r} U+{r.Value:X4}");

// ✓ 按"用户看到的字符"遍历（处理组合字、肤色 emoji）
var e = StringInfo.GetTextElementEnumerator(s);
while (e.MoveNext()) Console.WriteLine(e.Current);

// 编码转换：.NET 的默认编码是 UTF-8（无 BOM）
byte[] utf8  = Encoding.UTF8.GetBytes(s);
string back  = Encoding.UTF8.GetString(utf8);
byte[] utf16 = Encoding.Unicode.GetBytes(s);   // Unicode = UTF-16 LE，别被名字骗了

"i".ToUpper(InvariantCulture)  = "I"
"i".ToUpper(tr-TR)             = "İ"    // 土耳其语的大写 i 带点！

"a".CompareTo("B")     = -1     // 按中文区域：a 排在 B 前（字母序）
string.CompareOrdinal("a","B") = 31     // 按码位：'a'(97) > 'B'(66)，正数

排序 ["赵","钱","孙","李"]:
  Ordinal 序: 孙 李 赵 钱       // 按 Unicode 码位
  zh-CN  序: 李 钱 孙 赵       // 按拼音

using System.Globalization;

// ✓ 判断扩展名、协议头这类"标识符"：Ordinal
if (path.EndsWith(".json", StringComparison.OrdinalIgnoreCase)) { }
if (header.Equals("content-type", StringComparison.OrdinalIgnoreCase)) { }

// ✗ 危险写法：ToLower 之后比较
if (path.ToLower().EndsWith(".json")) { }   // 土耳其区域会出错，还多分配一个字符串

// ✓ 给用户看的排序：显式区域
var sorted = names.OrderBy(n => n, StringComparer.Create(
    CultureInfo.GetCultureInfo("zh-CN"), ignoreCase: false));

// ✓ 字典 key 忽略大小写：把比较器交给字典，别自己 ToLower
var map = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

// 规范化大小写用 Invariant 版本，绝不用 ToLower()/ToUpper() 无参重载
var key = raw.ToUpperInvariant();

foreach (var x in items) { }        // 首选：只读遍历，不用管索引和边界
for (int i = 0; i < n; i++) { }     // 需要索引、或要跳步/倒序
while (cond) { }                    // 次数不确定
do { } while (cond);                // 至少执行一次（很少用）

var s = "0123456789";
s[2]        // '2'
s[^1]       // '9'  —— ^ 表示"从末尾数"，^1 是最后一个
s[2..5]     // "234" —— 左闭右开
s[^3..]     // "789" —— 最后三个
s[..^1]     // "012345678" —— 去掉最后一个

// 边遍历边删：倒序 for，或先快照
for (int i = list.Count - 1; i >= 0; i--)
    if (list[i].IsExpired) list.RemoveAt(i);

list.RemoveAll(x => x.IsExpired);      // List<T> 自带，更短更快

// 范围切片：解析固定宽度的文本
ReadOnlySpan<char> line = raw.AsSpan();
var code = line[..3];              // 零分配
var name = line[3..20].Trim();
var tail = line[^8..];

// 带索引的 foreach（.NET 9+）
foreach (var (i, item) in items.Index())
    Console.WriteLine($"{i}: {item}");

// switch 语句：啰嗦，还必须每个分支 break
string label;
switch (code)
{
    case 200: label = "成功"; break;
    case 404: label = "未找到"; break;
    default:  label = "其它";  break;
}

// switch 表达式：整体是一个值，可以直接赋给变量/return
string label = code switch
{
    200 => "成功",
    404 => "未找到",
    _   => "其它",           // _ 是"其余情况"
};

// 典型用法：把状态映射成展示文本
string desc = status switch
{
    OrderStatus.Pending   => "待付款",
    OrderStatus.Paid      => "已付款",
    OrderStatus.Shipped   => "已发货",
    OrderStatus.Cancelled => "已取消",
    // 故意不写 _：以后加了新状态，这里会亮警告
};

// 关系模式 + 逻辑模式：区间判断不用写一串 if
string grade = score switch
{
    < 0 or > 100 => throw new ArgumentOutOfRangeException(nameof(score)),
    >= 90        => "A",
    >= 80        => "B",
    >= 60        => "C",
    _              => "F",
};

// 带守卫（when）：模式之外再加任意布尔条件
var fee = (kind, weight) switch
{
    (Kind.Express, var w) when w > 10 => w * 3.0m,
    (Kind.Express, _)               => 25m,
    (_, var w)                       => w * 1.5m,
};

object[] samples = [42, "hi", 3.14, new PointR(1,2), null, new[]{1,2,3}];

foreach (var s in samples)
    Console.WriteLine(s switch
    {
        null                              => "null",              // ① 常量模式
        int n when n > 40                 => $"大 int {n}",       // ② 类型模式 + 守卫
        int n                             => $"int {n}",
        string { Length: > 5 }            => "长字符串",           // ③ 属性模式
        string str                        => $"字符串 {str}",
        PointR(var x, var y)              => $"解构 record ({x},{y})",  // ④ 位置模式
        int[] a when a is [1, .. var rest] => $"以 1 开头，其余 {rest.Length} 个", // ⑤ 列表模式
        _                                 => $"其它 {s.GetType().Name}",
    });

// 输出：
大 int 42 / 字符串 hi / 其它 Double / 解构 record (1,2) / null / 以 1 开头，其余 2 个

// 属性模式嵌套：从深层结构里一次取出需要的字段
if (evt is { Type: "order.paid", Data.Amount: > 1000 and < 100000, Data.Currency: "CNY" })
    HandleBigOrder(evt);

// 列表模式解析命令行
string result = args switch
{
    []                          => "用法: tool <命令> [参数]",
    ["help"]                    => Help(),
    ["add", var file]           => Add(file),
    ["add", .. var files]       => AddMany(files),
    [var unknown, ..]           => $"未知命令 {unknown}",
};

// 元组模式：多个条件的组合表
var action = (isLoggedIn, isAdmin) switch
{
    (false, _)    => "跳转登录",
    (true, true)  => "进入后台",
    (true, false) => "进入首页",
};

(int, string) t = (1, "a");            // 位置元素：t.Item1 / t.Item2
var named = (Id: 1, Name: "a");        // 命名元素：named.Id / named.Name（推荐）

var (id, name) = named;                // 解构成两个变量
(a, b) = (b, a);                       // 一行交换，不需要临时变量

// 方法返回多值：不用为了两个字段专门建个类
static (bool ok, string? error) Validate(string s)
    => s.Length > 0 ? (true, null) : (false, "不能为空");

var (ok, error) = Validate(input);

// 字典遍历：KeyValuePair 自带解构
foreach (var (key, value) in dict)
    Console.WriteLine($"{key} = {value}");

// 自定义类型支持解构
public class Rect(double w, double h)
{
    public double W { get; } = w;
    public double H { get; } = h;
    public void Deconstruct(out double w, out double h) => (w, h) = (W, H);
}
var (w, h) = new Rect(3, 4);

// 元组做临时分组 + LINQ
var stats = orders
    .GroupBy(o => o.CustomerId)
    .Select(g => (Customer: g.Key, Count: g.Count(), Total: g.Sum(o => o.Amount)))
    .OrderByDescending(x => x.Total)
    .ToList();

foreach (var (customer, count, total) in stats)
    Console.WriteLine($"{customer}: {count} 单 / {total:C}");

static IEnumerable<int> Fib()
{
    int a = 0, b = 1;
    while (true)                 // 无限循环！
    {
        yield return a;
        (a, b) = (b, a + b);
    }
}

Fib().Take(8)                    // 0,1,1,2,3,5,8,13 —— 不会卡死

// 逐行读大文件：内存占用与文件大小无关
static IEnumerable<string> ReadLines(string path)
{
    using var reader = new StreamReader(path);      // finally 里会被正确释放
    string? line;
    while ((line = reader.ReadLine()) != null)
        yield return line;
}

// 正确的参数校验：外层普通方法 + 内层迭代器
public static IEnumerable<T> TakeEvery<T>(this IEnumerable<T> src, int n)
{
    ArgumentNullException.ThrowIfNull(src);            // 立即校验
    ArgumentOutOfRangeException.ThrowIfNegativeOrZero(n);
    return Iterate(src, n);                            // 惰性部分单独放

    static IEnumerable<T> Iterate(IEnumerable<T> s, int k)
    {
        int i = 0;
        foreach (var x in s) if (i++ % k == 0) yield return x;
    }
}

// 异步迭代器（C# 8+）：await 和 yield 可以共存
static async IAsyncEnumerable<string> FetchPagesAsync(string url)
{
    string? next = url;
    while (next is not null)
    {
        var page = await http.GetFromJsonAsync<Page>(next);
        yield return page!.Body;
        next = page.Next;
    }
}
// 消费：await foreach (var body in FetchPagesAsync(url)) { ... }

// ① 重载：同名不同参数列表（返回类型不参与区分！）
void Log(string msg) { }
void Log(string msg, Exception ex) { }

// ② 可选参数：调用方可以不传
void Send(string to, int retries = 3, bool urgent = false) { }

// ③ 命名实参：跳过中间的可选参数，顺便自解释
Send("a@b.c", urgent: true);          // retries 用默认值 3

// ④ 表达式体：一行方法不用写大括号和 return
int Square(int x) => x * x;
string Name => $"{First} {Last}";     // 属性也能用

public class Report
{
    // 表达式体成员：构造、属性、方法、索引器都能用
    public Report(string title) => Title = title;
    public string Title { get; }
    public string Slug => Title.ToLowerInvariant().Replace(' ', '-');

    // nameof：把标识符变成字符串，重命名时跟着变
    public void Validate()
    {
        if (string.IsNullOrWhiteSpace(Title))
            throw new ArgumentException("标题不能为空", nameof(Title));
    }

    // 局部函数：static 表示不捕获外层变量
    public int Score(IEnumerable<int> xs)
    {
        return xs.Select(Weight).Sum();

        static int Weight(int x) => x > 0 ? x * 2 : 0;
    }
}

void Bump(PointS s, PointC c)
{
    s.X++;              // 值类型副本：外面看不见
    c.X++;              // 通过引用副本改对象：外面看得见 ✓
    c = new PointC();   // 把引用副本指向新对象：外面看不见 ✗
}
// s.X 仍是 1，c.X 变成 2

// out：TryXxx 模式，C# 里最常见的 out 用法
public static bool TryGetConfig(string key, out string? value)
{
    value = Environment.GetEnvironmentVariable(key);
    return value is not null;
}
if (TryGetConfig("PORT", out var port)) { /* 用 port */ }

// ref：就地修改
static void Double(ref int x) => x *= 2;
int n = 5; Double(ref n);        // n == 10

// in + readonly struct：避免大结构体复制
public readonly struct Matrix4 { /* 64 字节 */ }
static double Trace(in Matrix4 m) => m.M11 + m.M22 + m.M33 + m.M44;

// params：可变参数
static int SumAll(params ReadOnlySpan<int> xs)   // C# 13+：调用时零分配
{
    int s = 0;
    foreach (var x in xs) s += x;
    return s;
}
SumAll(1, 2, 3);

delegate bool Predicate(int x);        // ① 自定义委托类型（今天很少写了）

Func<int, bool>  isPos = x => x > 0;   // ② Func：有返回值，最后一个类型参数是返回类型
Action<string>   log   = s => Console.WriteLine(s);  // ③ Action：无返回值
Predicate<int>   pred  = x => x > 0;   // BCL 自带的 Predicate<T>，等价于 Func<T,bool>

isPos(5);  log("hi");                   // 像方法一样调用
list.Where(isPos);                      // 也可以当值传

var a = new List<Func<int>>();
foreach (var i in Enumerable.Range(0,3)) a.Add(() => i);
// 输出：0,1,2   —— 每轮一个新变量

var b = new List<Func<int>>();
for (int i = 0; i < 3; i++) b.Add(() => i);
// 输出：3,3,3   —— 三个 lambda 共享同一个 i

// 委托作为策略参数：把"怎么做"交给调用方
public static T Retry<T>(Func<T> action, int times = 3,
                        Action<Exception, int>? onError = null)
{
    for (int i = 1; ; i++)
    {
        try { return action(); }
        catch (Exception e) when (i < times)
        {
            onError?.Invoke(e, i);      // ?.Invoke：委托可能是 null
        }
    }
}

var html = Retry(() => http.GetStringAsync(url).Result,
                  onError: (e, n) => logger.LogWarning("第 {N} 次失败", n));

// 方法组转换与 static lambda
var nums = lines.Select(int.Parse);              // 方法组，不写 lambda
var big  = nums.Where(static x => x > 100);      // static：编译器确认无捕获

// 多播委托：一个委托可以挂多个方法（事件的基础）
Action pipeline = () => Console.WriteLine("A");
pipeline += () => Console.WriteLine("B");
pipeline();                                    // 依次输出 A、B

public class Downloader
{
    // BCL 约定：EventHandler<T>，参数是 (object? sender, T e)
    public event EventHandler<ProgressEventArgs>? Progress;

    protected virtual void OnProgress(int percent)
        => Progress?.Invoke(this, new ProgressEventArgs(percent));
        // ?.Invoke 是必须的：没人订阅时委托是 null
}

// 订阅方
d.Progress += (sender, e) => Console.WriteLine($"{e.Percent}%");

public class FileWatcher : IDisposable
{
    private readonly Downloader _source;
    private readonly EventHandler<ProgressEventArgs> _handler;

    public FileWatcher(Downloader source)
    {
        _source = source;
        _handler = OnProgress;        // 存下来，退订时要用同一个实例
        _source.Progress += _handler;
    }

    private void OnProgress(object? sender, ProgressEventArgs e)
        => Console.WriteLine($"{e.Percent}%");

    public void Dispose() => _source.Progress -= _handler;   // 必须退订
}

// 事件参数：轻量 record 就够，不必非要继承 EventArgs（那是老约定）
public sealed record ProgressEventArgs(int Percent);

public static class StringExtensions      // 必须是静态类
{
    public static string Shout(this string s)   // 第一个参数加 this
        => s.ToUpperInvariant() + "!";
}

"hello".Shout()          // 输出 HELLO! —— 看起来是 string 的方法
StringExtensions.Shout("hello")             // 编译后其实是这个

((string?)null).IsBlank()      // 返回 True，不抛 NullReferenceException！

public static bool IsBlank(this string? s) => string.IsNullOrWhiteSpace(s);

// 常见的实用扩展
public static class EnumerableExtensions
{
    // 给 IEnumerable<T> 补一个"分批"（.NET 6+ 已内置 Chunk，这里作示例）
    public static IEnumerable<List<T>> Batch<T>(this IEnumerable<T> src, int size)
    {
        var buf = new List<T>(size);
        foreach (var x in src)
        {
            buf.Add(x);
            if (buf.Count == size) { yield return buf; buf = new(size); }
        }
        if (buf.Count > 0) yield return buf;
    }
}

// C# 14 的扩展成员：能扩展属性和静态成员了
public static class StringExt
{
    extension(string s)
    {
        public bool IsBlank => string.IsNullOrWhiteSpace(s);   // 扩展属性
        public string Truncate(int n) => s.Length <= n ? s : s[..n] + "…";
    }
}
// 用起来：if (name.IsBlank) ...

// 老写法：私有字段 + 手写属性 + 构造函数
public class User
{
    private readonly string _name;
    public string Name { get { return _name; } }
    public User(string name) { _name = name; }
}

// 自动属性 + 主构造函数（C# 12）：同样的语义，三行
public class User(string name)
{
    public string Name { get; } = name;
}

// 只做数据容器？直接 record（下一卡）
public record User(string Name);

public string Name
{
    get;
    set => field = value?.Trim() ?? throw new ArgumentNullException(nameof(value));
}
// 以前必须为此手写一个私有字段 _name；现在 field 直接指代编译器生成的那个

public class Order
{
    // 只读：构造后不可变
    public required string Id { get; init; }
    public required decimal Amount { get; init; }

    // 带默认值的自动属性
    public DateTimeOffset CreatedAt { get; init; } = DateTimeOffset.UtcNow;

    // 计算属性：没有存储，每次算
    public bool IsLarge => Amount > 10_000m;

    // 可变但有校验
    public string? Note
    {
        get;
        set => field = value?.Trim();     // C# 14 的 field 关键字
    }

    // 私有状态用字段
    private readonly List<OrderLine> _lines = [];
    public IReadOnlyList<OrderLine> Lines => _lines;   // 对外只读视图
}

// 用对象初始化器构造，required 保证不漏字段
var o = new Order { Id = "A-1", Amount = 99.5m };

class Base    { public virtual string Virt() => "Base.Virt";
                public         string Shadow() => "Base.Shadow"; }
class Derived : Base { public override string Virt() => "Derived.Virt";
                       public new    string Shadow() => "Derived.Shadow"; }

Base b = new Derived();
b.Virt()                  // "Derived.Virt"  ← 运行时类型说了算（多态）
b.Shadow()                // "Base.Shadow"   ← 编译期类型说了算（遮蔽）
((Derived)b).Shadow()     // "Derived.Shadow"

// 抽象基类：定义模板流程，把变化点留给子类
public abstract class Exporter
{
    // 模板方法：流程固定
    public async Task RunAsync(IEnumerable<Row> rows, Stream output)
    {
        await using var w = new StreamWriter(output);
        await w.WriteLineAsync(Header());
        foreach (var r in rows) await w.WriteLineAsync(Format(r));
    }

    protected abstract string Header();          // 子类必须实现
    protected abstract string Format(Row r);
}

public sealed class CsvExporter : Exporter
{
    protected override string Header() => "id,name,amount";
    protected override string Format(Row r) => $"{r.Id},{r.Name},{r.Amount}";
}

// 组合替代继承：把"怎么格式化"作为依赖注入进来
public sealed class Exporter2(IRowFormatter formatter)
{
    public async Task RunAsync(IEnumerable<Row> rows, Stream output) { /* ... */ }
}

interface IShape
{
    double Area();                                  // ① 纯契约
    string Describe() => $"面积 {Area():F1} 的图形";  // ② 默认实现（C# 8+）
    static abstract IShape Parse(string s);         // ③ 静态抽象（C# 11+）
}

record Circle(double R) : IShape { public double Area() => Math.PI * R * R; }

IShape s = new Circle(2);
s.Area()        // 12.57
s.Describe()    // "面积 12.6 的图形" ——，接口默认实现生效

class Doc : IPrintable
{
    string IPrintable.Print() => "只能通过接口调用";   // 没有访问修饰符！
}

new Doc().Print()          // 编译错误：Doc 上没有 Print
((IPrintable)new Doc()).Print()   // 正常，输出"只能通过接口调用"

// 小接口 + 组合：典型的可测试设计
public interface IClock { DateTimeOffset UtcNow(); }
public interface IRateLimiter { Task<bool> TryAcquireAsync(string key); }

public sealed class CouponService(IClock clock, IRateLimiter limiter)
{
    public async Task<bool> RedeemAsync(Coupon c)
        => c.ExpiresAt > clock.UtcNow()
        && await limiter.TryAcquireAsync(c.Code);
}

// 测试里塞一个假的时钟，就能测"过期"分支——不用等到明天
sealed class FakeClock(DateTimeOffset t) : IClock
{
    public DateTimeOffset UtcNow() => t;
}

// 泛型 + 静态抽象：一个方法吃所有数值类型（.NET 7+）
static T Sum<T>(IEnumerable<T> xs) where T : INumber<T>
{
    T acc = T.Zero;                       // 静态抽象成员
    foreach (var x in xs) acc = acc + x;
    return acc;
}

record PointR(int X, int Y);

new PointR(1,2) == new PointR(1,2)     // True  —— 逐属性比较（class 是 False）
new PointR(1,2).ToString()             // "PointR { X = 1, Y = 2 }"
var r2 = r1 with { Y = 9 };            // "PointR { X = 1, Y = 9 }"，r1 原封不动
var (x, y) = r1;                       // 自动解构

record Person(string Name, int Age);
record Student(string Name, int Age, string Major) : Person(Name, Age);

Person p1 = new Student("A", 20, "CS");
Person p2 = new Student("A", 20, "CS");
p1 == p2                       // True

Person p3 = new Person("A", 20);
p3 == (Person)p1               // False！—— 尽管 Name 和 Age 都一样

// DTO / API 契约：record + required + init
public sealed record CreateOrderRequest
{
    public required string CustomerId { get; init; }
    public required IReadOnlyList<Line> Lines { get; init; }
    public string? Coupon { get; init; }
}

// 值对象：用 readonly record struct 包装原始类型，避免"参数传反了"
public readonly record struct UserId(Guid Value)
{
    public override string ToString() => Value.ToString("N");
}
// void Transfer(UserId from, UserId to) —— 传反了编译不过；
// 如果两个参数都是 Guid，传反了只有线上才知道

// 领域事件：record 的相等性和 ToString 让日志与测试都省事
public abstract record DomainEvent(DateTimeOffset OccurredAt);
public sealed record OrderPaid(string OrderId, decimal Amount, DateTimeOffset OccurredAt)
    : DomainEvent(OccurredAt);

// with 做状态推进
var shipped = order with { Status = OrderStatus.Shipped, ShippedAt = clock.UtcNow() };

// ✓ 典型的好 struct：小、不可变、像一个值
public readonly record struct Money(decimal Amount, string Currency)
{
    public static Money operator +(Money a, Money b) =>
        a.Currency == b.Currency
            ? a with { Amount = a.Amount + b.Amount }
            : throw new InvalidOperationException("币种不同不能相加");
}

// ✗ 典型的坏 struct：可变 + 有集合字段
public struct BadCart          // 别这么写
{
    public List<string> Items;   // 引用字段：复制 struct 时两份共享同一个 List
    public int Count;            // 可变字段：改副本改不到原件
}

// ref struct：只活在栈上，用于零分配解析
public ref struct LineReader(ReadOnlySpan<char> text)
{
    private ReadOnlySpan<char> _rest = text;

    public bool TryReadLine(out ReadOnlySpan<char> line)
    {
        int i = _rest.IndexOf('\n');
        if (i < 0) { line = _rest; _rest = default; return line.Length > 0; }
        line = _rest[..i]; _rest = _rest[(i + 1)..];
        return true;
    }
}

using (var f = File.OpenRead(path)) { ... }   // 块结束时 Dispose
using var f = File.OpenRead(path);            // C# 8+：作用域结束时 Dispose
await using var conn = new SqlConnection(cs); // IAsyncDisposable

// 的释放顺序：嵌套 using 是"后进先出"
using (var outer = new Noisy("外"))
using (var inner = new Noisy("内")) { }
// 输出：Dispose 内 → Dispose 外

// 标准的 IDisposable 实现（持有其它 IDisposable 时）
public sealed class Repository : IDisposable, IAsyncDisposable
{
    private readonly DbConnection _conn;
    private bool _disposed;

    public Repository(string cs) => _conn = new SqlConnection(cs);

    public void Dispose()
    {
        if (_disposed) return;      // Dispose 必须可以被调用多次
        _conn.Dispose();
        _disposed = true;
    }

    public async ValueTask DisposeAsync()
    {
        if (_disposed) return;
        await _conn.DisposeAsync();
        _disposed = true;
    }
    // 注意：没有终结器 —— 因为这里没有直接持有非托管资源
}

// 懒加载单例：静态构造函数版本（线程安全由运行时保证）
public static class Config
{
    public static readonly IReadOnlyDictionary<string, string> Values;
    static Config() => Values = Load();
}

// 更现代的做法：交给 DI 容器（17 章）
// builder.Services.AddSingleton<IConfigStore, ConfigStore>();

① typeof(string) == typeof(string?)      // True —— 就是同一个类型

② static string Greet(string name) => $"hi {name.Length}";
   Greet(null!)                          // 编译通过，运行时抛 NullReferenceException

③ 元数据里只是多了个特性：
   Box.Name（required string）→ RequiredMemberAttribute
   Box.Tag （string?）        → NullableAttribute

string? s = null;
Console.WriteLine(s.Length);

warning CS8602: 解引用可能出现空引用。     // 只是警告
// 程序照常编译、照常运行、照常在第 2 行抛 NullReferenceException

// csproj：新项目模板默认已经开了 Nullable，但没把警告变成错误
<PropertyGroup>
  <Nullable>enable</Nullable>
  <WarningsAsErrors>nullable</WarningsAsErrors>   <!-- 关键的一行 -->
</PropertyGroup>

// 四种可空上下文的粒度
#nullable enable       // 标注 + 警告都开（默认）
#nullable disable      // 全关（迁移旧文件时临时用）
#nullable enable annotations   // 只认标注，不报警告
#nullable restore      // 回到 csproj 的设定

// 典型的边界处理：外部数据一律当作可空
string? raw = Environment.GetEnvironmentVariable("API_KEY");
if (raw is null)
    throw new InvalidOperationException("缺少 API_KEY");
// 从这一行往后，编译器知道 raw 不是 null 了
Console.WriteLine(raw.Length);

string? s = GetName();

if (s is null) return;
Console.WriteLine(s.Length);        // ✓ 不警告：这条路径上 s 一定非空

if (s is not null && s.Length > 0) { }        // ✓ 短路后的收窄
if (string.IsNullOrEmpty(s)) return;
Console.WriteLine(s.Length);        // ✓ BCL 方法带了 [NotNullWhen] 标注

var len = s?.Length ?? 0;           // ✓ 空条件 + 空合并
if (s is { Length: > 0 }) { }       // ✓ 属性模式隐含非空

using System.Diagnostics.CodeAnalysis;

// 让自定义的判空方法参与流分析
public static bool TryGetName(User? u, [NotNullWhen(true)] out string? name)
{
    name = u?.Name;
    return name is not null;
}

if (TryGetName(user, out var name))
    Console.WriteLine(name.Length);      // ✓ 不警告

// 抛异常的辅助方法：标注后调用它之后的代码会被视为"一定非空"
[DoesNotReturn]
static void Fail(string msg) => throw new InvalidOperationException(msg);

// 延迟初始化的字段：告诉编译器 Init 之后 _conn 一定有值
private DbConnection? _conn;

[MemberNotNull(nameof(_conn))]
private void EnsureConnected()
{
    _conn ??= new SqlConnection(_cs);
}

public void Query()
{
    EnsureConnected();
    _conn.Open();        // ✓ 不警告，因为上面的 MemberNotNull
}

// BCL 里已经标好的：ThrowIfNull 之后不再警告
ArgumentNullException.ThrowIfNull(input);
Console.WriteLine(input.Length);          // ✓

// ✗ 老办法一：用 ! 骗过编译器（把问题推到运行时）
public string Name { get; set; } = null!;

// ✗ 老办法二：改成可空，然后到处判空（污染了整个下游）
public string? Name { get; set; }

// ✓ 正确答案：required（C# 11+）
public required string Name { get; init; }
// new Box { Name = "x" }  ✓ 通过
// new Box { }             ✗ 编译错误：必须设置 Name

// ✓ required + init：DTO 的标准形态
public sealed record Customer
{
    public required string Id { get; init; }
    public required string Name { get; init; }
    public string? Nickname { get; init; }      // 明确表示"可以没有"
}

// 让 System.Text.Json 能构造带 required 的类型
public sealed class Dto
{
    public required string Name { get; init; }

    [SetsRequiredMembers]
    public Dto(string name) => Name = name;
}

// 泛型约束让 T? 的含义变明确
static T? FirstOrNull<T>(IEnumerable<T> xs) where T : class
    => xs.FirstOrDefault();

static T? FirstOrNull<T>(IEnumerable<T> xs) where T : struct
    => xs.Cast<T?>().FirstOrDefault();

// 字典 key 不许为空
static void Add<TKey, TValue>(Dictionary<TKey, TValue> d, TKey k, TValue v)
    where TKey : notnull { d[k] = v; }

// 逐文件迁移：文件顶部一行
#nullable enable

// 边界防御：所有外部输入在入口处收敛
public sealed class OrderController
{
    public IResult Create(CreateOrderRequest? req)
    {
        if (req is null) return Results.BadRequest("请求体不能为空");
        // 从这里往下，整个方法体内 req 都是非空的
        return Results.Ok(_service.Create(req));
    }
}

// 集合永远不返回 null —— 这条比任何标注都省事
public IReadOnlyList<Order> FindByCustomer(string id)
    => _db.Orders.Where(o => o.CustomerId == id).ToList();   // 没有就是空列表

// System.Text.Json 尊重可空标注（.NET 9+）
var options = new JsonSerializerOptions
{
    RespectNullableAnnotations = true,     // 缺字段 / 显式 null → 抛异常而不是静默塞 null
    RespectRequiredConstructorParameters = true,
};

20 万元素的集合，做 2 万次查找（Release 构建）：

List<int>.Contains      218 ms      // O(n) × 2 万次
HashSet<int>.Contains     0 ms      // O(1) × 2 万次，快到测不出
Dictionary.ContainsKey    0 ms

// 把 O(n²) 改成 O(n)：一行的事
var blocked = blockedList.ToHashSet();               // 建一次索引
var allowed = users.Where(u => !blocked.Contains(u.Id));

// 分组统计的惯用法：字典 + 默认值
var counts = new Dictionary<string, int>();
foreach (var w in words)
    counts[w] = counts.GetValueOrDefault(w) + 1;

// 集合运算：HashSet 自带
var a = new HashSet<int>([1, 2, 3]);
a.UnionWith([3, 4]);        // 并集   {1,2,3,4}
a.IntersectWith([2, 3]);    // 交集   {2,3}
a.ExceptWith([2]);         // 差集   {3}

// 只读查表：FrozenSet / FrozenDictionary（.NET 8+）
// 构建慢一点，之后的查找比 HashSet/Dictionary 还快 —— 适合启动时建好、全程只读
private static readonly FrozenSet<string> Reserved =
    new[] { "admin", "root", "system" }.ToFrozenSet(StringComparer.OrdinalIgnoreCase);

int calls = 0;
IEnumerable<int> Src() { for (int i=1; i<=3; i++) { calls++; yield return i; } }

var q = Src().Where(x => x % 2 == 1).Select(x => x * 10);
calls == 0                     // 定义查询后：一次都没执行！

string.Join(",", q)  → "10,30"; calls == 3     // 第一次枚举，跑了 3 个元素
string.Join(",", q)  → "10,30"; calls == 6     // 第二次枚举：又跑了一遍！

var cached = q.ToList();       calls == 9      // ToList 触发第三遍
foreach (var _ in cached) { }  calls == 9      // 之后随便遍历，不再重跑

// 方法语法（method syntax）—— 90% 的人只用这个
var r = people.Where(p => p.Age > 18).OrderBy(p => p.Name).Select(p => p.Name);

// 查询语法（query syntax）—— 像 SQL，多表 join / 多重 from 时更清楚
var r2 = from p in people
         where p.Age > 18
         orderby p.Name
         select p.Name;

// 一条典型的 LINQ 链：读起来就是需求本身
var top = orders
    .Where(o => o.Status == OrderStatus.Paid)          // 筛选
    .Where(o => o.CreatedAt >= start)                   // 多个 Where 会被合并成一次遍历
    .GroupBy(o => o.CustomerId)                          // 分组
    .Select(g => new                                     // 投影成匿名类型
    {
        Customer = g.Key,
        Count    = g.Count(),
        Total    = g.Sum(o => o.Amount),
    })
    .Where(x => x.Total > 10_000m)
    .OrderByDescending(x => x.Total)
    .Take(10)
    .ToList();                                            // 到这里才真正执行

// 惰性的价值：只要前 3 个，就只算 3 个
var firstThree = HugeSequence()
    .Where(ExpensiveCheck)
    .Take(3)
    .ToList();          // ExpensiveCheck 只会被调用到凑够 3 个为止

空序列.First()          → InvalidOperationException: Sequence contains no elements
空序列.FirstOrDefault() → 0        // int 的 default 是 0，不是 null！
空序列.FirstOrDefault(-1) → -1     // .NET 6+ 可以自己给默认值
两个元素.Single()       → InvalidOperationException: Sequence contains more than one element

// SelectMany：展平嵌套
var allLines = orders.SelectMany(o => o.Lines);
var withOwner = orders.SelectMany(o => o.Lines, (o, l) => (o.Id, l.Sku, l.Qty));

// 多级排序
var sorted = people
    .OrderBy(p => p.Department)
    .ThenByDescending(p => p.Salary)
    .ThenBy(p => p.Name, StringComparer.Ordinal);   // 可指定比较器（03 章）

// MinBy / MaxBy：要的是"哪个元素"而不是"最大值是多少"
var richest = people.MaxBy(p => p.Salary);      // 返回 Person
var maxSalary = people.Max(p => p.Salary);      // 返回 decimal

// 判空：Any 比 Count 好——Any 找到一个就返回
if (orders.Any(o => o.IsOverdue)) { }         // ✓
if (orders.Count(o => o.IsOverdue) > 0) { }   // ✗ 要数完整个序列

// Chunk：批量处理（每 500 条提交一次）
foreach (var batch in items.Chunk(500))
    await _db.BulkInsertAsync(batch);

people.GroupBy(p => p.Age)     // IEnumerable<IGrouping<int, Person>>

// （输入 张30 李25 王30 赵25）：
年龄 25: 李,赵
年龄 30: 张,王

var lk = items.ToLookup(x => x % 3);
lk[0]      // 0,3,6,9
lk[99]     // 返回空序列，不抛异常 ← 与 Dictionary 的关键差别

// 分组聚合：一次算出每个客户的单数与总额
var stats = orders
    .GroupBy(o => o.CustomerId)
    .Select(g => new
    {
        CustomerId = g.Key,
        Count      = g.Count(),
        Total      = g.Sum(o => o.Amount),
        Latest     = g.Max(o => o.CreatedAt),
    })
    .OrderByDescending(x => x.Total);

// 多键分组：用元组当 key（元组的相等性是逐元素的，02 章）
var byMonth = orders.GroupBy(o => (o.CreatedAt.Year, o.CreatedAt.Month));

// 左连接的实用写法：Lookup + 空合并
var byCustomer = orders.ToLookup(o => o.CustomerId);
var report = customers.Select(c => new
{
    c.Name,
    Orders = byCustomer[c.Id].ToList(),      // 没有订单就是空列表，不用判空
});

// 内连接：标准 Join
var joined = orders.Join(
    customers,
    o => o.CustomerId,        // 外层的 key
    c => c.Id,                // 内层的 key
    (o, c) => new { o.Id, c.Name, o.Amount });

var q = db.Orders.Where(o => o.IsPaid);     // 只是说明书
if (q.Any())                                // 第 1 次执行
    Console.WriteLine(q.Count());           // 第 2 次
foreach (var o in q) { }                    // 第 3 次

var threshold = 10;
var q = items.Where(x => x > threshold);
threshold = 100;                 // 改了变量
q.ToList();                      // 用的是 100，不是 10！

// ✗ 常见错误：以为 q 是结果
var q = source.Where(Expensive);
Console.WriteLine($"共 {q.Count()} 条");      // 跑一遍
foreach (var x in q) Handle(x);              // 又跑一遍

// ✓ 物化一次
var list = source.Where(Expensive).ToList();
Console.WriteLine($"共 {list.Count} 条");       // 用 Count 属性，不是 Count()
foreach (var x in list) Handle(x);

// ✗ 方法返回延迟查询 + 内部有 using：调用方枚举时流已关闭
public IEnumerable<Row> Load(string path)
{
    using var r = new StreamReader(path);
    return Parse(r).Where(x => x.IsValid);      // 返回时 r 已被释放！
}

// ✓ 要么物化，要么把 using 放进迭代器里（04 章的 yield 写法）
public IReadOnlyList<Row> Load(string path)
{
    using var r = new StreamReader(path);
    return Parse(r).Where(x => x.IsValid).ToList();
}

// ✗ AsEnumerable / ToList 之后，后面的条件全部在内存里做
var r = db.Orders.ToList()                  // ← 把整张表拉进内存！
              .Where(o => o.Amount > 100)
              .Take(10);

// ✓ 让数据库做筛选和分页
var r2 = await db.Orders
              .Where(o => o.Amount > 100)
              .OrderByDescending(o => o.CreatedAt)
              .Take(10)
              .ToListAsync();

using System.Linq.Expressions;

// 委托 vs 表达式树：只差一层 Expression<>
Func<Order, bool>             f = o => o.Amount > 100;   // 可执行
Expression<Func<Order, bool>> e = o => o.Amount > 100;   // 可分析

Console.WriteLine(e.Body);        // (o.Amount > 100) —— 能把自己打印出来
var compiled = e.Compile();       // 也能编译成委托再执行

// 正确的分页查询：所有条件都在数据库侧
public async Task<IReadOnlyList<OrderDto>> SearchAsync(
    string? keyword, int page, int size, CancellationToken ct)
{
    IQueryable<Order> q = _db.Orders.AsNoTracking();

    if (!string.IsNullOrWhiteSpace(keyword))          // 条件式组装：仍是 IQueryable
        q = q.Where(o => o.CustomerName.Contains(keyword));

    return await q
        .OrderByDescending(o => o.CreatedAt)
        .Skip((page - 1) * size).Take(size)     // 分页交给 SQL
        .Select(o => new OrderDto(o.Id, o.CustomerName, o.Amount))  // 只查需要的列
        .ToListAsync(ct);
}

手写 foreach + if:      4 ms
LINQ Where+Select+Sum: 239 ms

// 热路径上的等价改写（只在 profiler 指认后再做）
// LINQ 版：可读性最好
long sum = arr.Where(x => x % 2 == 0).Select(x => (long)x).Sum();

// 手写版：最快
long sum2 = 0;
foreach (var x in arr)
    if (x % 2 == 0) sum2 += x;

// 折中：用 Span 遍历，保留结构
long sum3 = 0;
foreach (var x in CollectionsMarshal.AsSpan(list))   // List<T> 的底层数组
    if (x % 2 == 0) sum3 += x;

// 量一量再说：BenchmarkDotNet 是 .NET 生态的标准答案
// [MemoryDiagnoser]
// public class Bench {
//     [Benchmark(Baseline = true)] public long Linq() => ...;
//     [Benchmark]                  public long Loop() => ...;
// }

class Cache<T> { }                        // 泛型类
interface IRepository<T> { }              // 泛型接口
static T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;       // 泛型方法

Max(3, 5);          // 类型推断：不用写 Max<int>(3, 5)
Max("a", "b");      // 同一个方法，另一个类型

static T? Def<T>() => default;

Def<int>()      // 0    ← 值类型的零值
Def<string>()   // null ← 引用类型的空引用

// 泛型类：一份实现，所有类型可用
public sealed class LruCache<TKey, TValue> where TKey : notnull
{
    private readonly Dictionary<TKey, LinkedListNode<(TKey, TValue)>> _map = [];
    private readonly LinkedList<(TKey, TValue)> _order = new();
    private readonly int _capacity;

    public LruCache(int capacity) => _capacity = capacity;

    public bool TryGet(TKey key, out TValue? value)     // TryXxx 而不是返回 default
    {
        if (!_map.TryGetValue(key, out var node)) { value = default; return false; }
        _order.Remove(node); _order.AddFirst(node);
        value = node.Value.Item2;
        return true;
    }
}

// 泛型方法 + 推断：调用处很干净
public static IReadOnlyList<TResult> MapNotNull<TSource, TResult>(
    this IEnumerable<TSource> src, Func<TSource, TResult?> selector)
    where TResult : class
    => src.Select(selector).OfType<TResult>().ToList();

var names = users.MapNotNull(u => u.Nickname);   // 两个类型参数都推断出来了

static T Sum<T>(IEnumerable<T> xs) where T : INumber<T>
{
    T acc = T.Zero;                // 通过类型参数调静态成员！
    foreach (var x in xs) acc += x;
    return acc;
}

Sum([1, 2, 3])       // 6
Sum([1.5, 2.5])      // 4

// 典型的仓储约束
public interface IEntity { Guid Id { get; } }

public class Repository<T> where T : class, IEntity, new()
{
    public T Create() => new T();                // new() 约束
    public T? Find(Guid id) => _items
        .FirstOrDefault(x => x.Id == id);          // IEntity 约束
}

// 泛型数学：一份实现服务 int / long / double / decimal / BigInteger
using System.Numerics;

public static T Average<T>(ReadOnlySpan<T> xs) where T : INumber<T>
{
    if (xs.IsEmpty) throw new ArgumentException("空序列", nameof(xs));
    T sum = T.Zero;
    foreach (var x in xs) sum += x;
    return sum / T.CreateChecked(xs.Length);
}

// 统一解析：IParsable<T>（.NET 7+）
public static T GetConfig<T>(string key, T fallback) where T : IParsable<T>
    => T.TryParse(Environment.GetEnvironmentVariable(key),
                    CultureInfo.InvariantCulture, out var v) ? v : fallback;

int port = GetConfig("PORT", 8080);
TimeSpan ttl = GetConfig("TTL", TimeSpan.FromMinutes(5));

List<Animal> animals = new List<Dog>();   // 假设允许……
animals.Add(new Cat());                   // 就能往 List<Dog> 里塞猫！

interface IEnumerable<out T> { }          // T 只作为返回值出现

IEnumerable<Animal> a = new List<Dog>();  // ✓ 合法

interface IComparer<in T> { int Compare(T a, T b); }

IComparer<Dog> c = someAnimalComparer;    // ✓ 能比较动物的，当然能比较狗

// 协变让 API 更好用：参数收 IEnumerable<基类>，调用方传 List<派生类>
void Feed(IEnumerable<Animal> animals) { }

Feed(new List<Dog>());        // ✓ 因为 IEnumerable<out T>

// 逆变让比较器可复用
class ByName : IComparer<Animal>
{
    public int Compare(Animal? a, Animal? b)
        => string.CompareOrdinal(a?.Name, b?.Name);
}
List<Dog> dogs = [];
dogs.Sort(new ByName());        // ✓ 因为 IComparer<in T>

// 自己定义协变接口：T 只能出现在返回位置
public interface IReadOnlyRepo<out T>
{
    T? Find(Guid id);              // ✓ 返回位置
    IEnumerable<T> All();           // ✓ 也算返回位置
    // void Save(T item);           ✗ 编译错误：T 是 out，不能作参数
}

// 泛型 + struct 约束：JIT 特化后可以完全内联，等价于手写
public static T MaxOf<T>(ReadOnlySpan<T> xs) where T : struct, IComparable<T>
{
    T best = xs[0];
    for (int i = 1; i < xs.Length; i++)
        if (xs[i].CompareTo(best) > 0) best = xs[i];   // 无装箱、可内联
    return best;
}

// 开放泛型 + 反射：DI 容器的核心技巧
var closed = typeof(Repository<>).MakeGenericType(entityType);
var repo = Activator.CreateInstance(closed)!;

// 一行注册所有 IRepository<T> 的实现（17 章的 DI）
// services.AddScoped(typeof(IRepository<>), typeof(EfRepository<>));

// 静态字段是"每个封闭类型一份"——常被用作类型级缓存
public static class TypeCache<T>
{
    public static readonly string Name = typeof(T).Name;   // 每个 T 各算一次
}
// TypeCache<int>.Name 和 TypeCache<string>.Name 是两个不同的静态字段

static int F()
{
    try { return 1; }
    finally { Console.WriteLine("finally"); }
}

// 输出顺序：
finally           // ← 先打印
返回值 = 1        // ← 后返回

try { Call(); }
catch (HttpRequestException e) when (e.StatusCode == HttpStatusCode.NotFound)
{
    return null;                    // 只接 404
}
catch (HttpRequestException e) when (IsTransient(e))
{
    await RetryAsync();             // 只接可重试的
}

// 典型的分层处理：具体的在前，通用的在后
try
{
    using var stream = File.OpenRead(path);
    return JsonSerializer.Deserialize<Config>(stream);
}
catch (FileNotFoundException)
{
    return Config.Default;                    // 可恢复：用默认值
}
catch (JsonException e)
{
    throw new ConfigException($"配置文件 {path} 格式错误", e);   // 包装后上抛
}
// 其它异常（权限、IO 错误）不接 —— 让上层决定

// 过滤器做重试判断，栈不展开
catch (SqlException e) when (e.Number is 1205 or -2)   // 死锁 / 超时
{
    await Task.Delay(backoff);
    goto retry;
}

// when 还能用来做"只记日志不处理"的窃听器（永远返回 false）
catch (Exception e) when (LogAndContinue(e)) { }   // LogAndContinue 恒返回 false

static void Deep()       => throw new InvalidOperationException("原始");
static void Rethrow()    { try { Deep(); } catch { throw; } }
static void RethrowEx()  { try { Deep(); } catch (Exception e) { throw e; } }

// 结果：
throw;      堆栈 3 帧，首帧 = Deep()        // ✓ 原始抛出点还在
throw e;    堆栈 2 帧，首帧 = RethrowEx()   // ✗ 抛出点被改写成了这里！

catch (Exception e) { throw new ApplicationException("包一层", e); }
// e.Message = "包一层"，e.InnerException.Message = "原始"

// ✓ 重抛：保留堆栈
try { Process(); }
catch (Exception e)
{
    _logger.LogError(e, "处理 {Id} 失败", id);
    throw;                      // 注意：没有 e
}

// ✓ 包装：加上下文，但保留内部异常
catch (JsonException e)
{
    throw new ConfigException($"配置文件 {path} 第 {e.LineNumber} 行解析失败", e);
}

// ✓ 跨上下文重抛
using System.Runtime.ExceptionServices;

ExceptionDispatchInfo? captured = null;
try { Work(); } catch (Exception e) { captured = ExceptionDispatchInfo.Capture(e); }
// ……稍后，在别处……
captured?.Throw();               // 原始堆栈完整保留

// 自定义异常：三个标准构造 + 有用的属性
public sealed class ConfigException : Exception
{
    public string? FilePath { get; init; }

    public ConfigException() { }
    public ConfigException(string message) : base(message) { }
    public ConfigException(string message, Exception inner) : base(message, inner) { }
}

// 公开 API 的参数校验：一行一条，放在方法最前面
public Order Create(string customerId, decimal amount, IReadOnlyList<Line> lines)
{
    ArgumentException.ThrowIfNullOrWhiteSpace(customerId);
    ArgumentOutOfRangeException.ThrowIfNegativeOrZero(amount);
    ArgumentNullException.ThrowIfNull(lines);
    if (lines.Count == 0)
        throw new ArgumentException("订单至少要有一行", nameof(lines));

    if (_state != State.Ready)                     // 状态不对 → InvalidOperation
        throw new InvalidOperationException($"当前状态 {_state} 不能下单");
    // ...
}

// 预期内的失败用返回值，不用异常
public Result<User> Register(string email)
    => _repo.Exists(email)
        ? Result<User>.Fail("邮箱已注册")         // 业务规则，不是异常
        : Result<User>.Ok(_repo.Add(email));

// 一个够用的 Result 类型（社区有 FluentResults、ErrorOr 等成熟实现）
public readonly record struct Result<T>(bool Success, T? Value, string? Error)
{
    public static Result<T> Ok(T v) => new(true, v, null);
    public static Result<T> Fail(string e) => new(false, default, e);
}

Unhandled exception. System.NullReferenceException:
  Object reference not set to an instance of an object.
   at Program.<Main>$(String[] args) in e5.cs:line 2

// 控制台/后台服务的全局兜底
AppDomain.CurrentDomain.UnhandledException += (_, e) =>
{
    var ex = e.ExceptionObject as Exception;
    Log.Fatal(ex, "未处理异常，进程即将终止 (IsTerminating={T})", e.IsTerminating);
    Log.CloseAndFlush();          // 关键：确保日志真的写出去了
};

// 抓"没人 await 的 Task 里的异常"
TaskScheduler.UnobservedTaskException += (_, e) =>
{
    Log.Error(e.Exception, "有 Task 抛了异常却没人观察");
    e.SetObserved();               // 标记为已处理，避免影响进程
};

// 顶层 try：给 CLI 工具一个体面的退出
try
{
    return await RunAsync(args);
}
catch (OperationCanceledException)
{
    Console.Error.WriteLine("已取消");
    return 130;                      // 约定：128 + SIGINT(2)
}
catch (Exception e)
{
    Console.Error.WriteLine(e.ToString());   // ToString 含整条 Inner 链
    return 1;
}

Console.WriteLine($"await 前 线程 {Environment.CurrentManagedThreadId}");   // 6
await Task.Delay(10);
Console.WriteLine($"await 后 线程 {Environment.CurrentManagedThreadId}");   // 6

SynchronizationContext.Current    // null（控制台程序没有同步上下文）
Thread.CurrentThread.IsThreadPoolThread   // True

// ✓ IO 密集：全程 async，一个线程都不占
public async Task<Report> BuildAsync(string id, CancellationToken ct)
{
    var user  = await _db.FindUserAsync(id, ct);
    var stats = await _http.GetFromJsonAsync<Stats>($"/stats/{id}", ct);
    return new Report(user, stats);
}

// ✓ CPU 密集：用 Task.Run 挪到线程池，别堵住调用方（尤其 UI 线程）
var thumbnail = await Task.Run(() => ResizeImage(bytes, 200, 200));

// ✗ 反模式：用 Task.Run 包装本来就有异步版本的 IO
var text = await Task.Run(() => File.ReadAllText(path));      // 浪费一个线程
var text2 = await File.ReadAllTextAsync(path);              // ✓

// 异步方法的命名约定：Async 后缀（不是硬性规定，但生态一致遵守）
public Task SaveAsync(CancellationToken ct = default);

Task.CompletedTask                  // 无返回值的已完成 Task —— 是单例（ReferenceEquals 为 True）
Task.FromResult(42)                 // 已完成且带结果；IsCompletedSuccessfully = True
Task.FromException(e) / FromCanceled(ct)
Task.Delay(ms, ct)                  // 定时器，不占线程
Task.Run(() => ...)                 // 丢到线程池执行
new ValueTask<int>(7)               // 同步就有结果，零分配

// 同步实现异步接口：零分配
public Task FlushAsync()
{
    _buffer.Clear();
    return Task.CompletedTask;      // 不要写 async 然后什么都不 await
}

// 缓存命中时同步返回：ValueTask 的教科书场景
public ValueTask<User> GetUserAsync(string id, CancellationToken ct)
{
    if (_cache.TryGetValue(id, out var cached))
        return new ValueTask<User>(cached);     // 同步路径：零分配

    return new ValueTask<User>(LoadAsync(id, ct));  // 异步路径：包一个 Task
}

// ✗ ValueTask 的误用（未定义行为）
var vt = GetUserAsync(id);
var a = await vt;
var b = await vt;                     // ✗ 只能 await 一次！

// ✓ 需要多次使用就转成 Task
Task<User> t = GetUserAsync(id).AsTask();

// 超时：给任何 Task 加超时的标准写法（.NET 6+）
await someTask.WaitAsync(TimeSpan.FromSeconds(5), ct);   // 超时抛 TimeoutException

// 串行：一个接一个（三个 200ms 任务耗时 625 ms）
await A(); await B(); await C();

// 并发：一起开始，等全部完成（同样三个任务 212 ms）
await Task.WhenAll(A(), B(), C());

// 竞速：谁先完成用谁
var winner = await Task.WhenAny(primary, fallback);

// ① Parallel.ForEachAsync（.NET 6+）—— 首选
await Parallel.ForEachAsync(items,
    new ParallelOptions { MaxDegreeOfParallelism = 5 },
    async (item, ct) => await ProcessAsync(item, ct));

// 20 个 100ms 任务、并发 5 → 444 ms（理论下限 400 ms）

// ② SemaphoreSlim —— 更灵活，可以跨方法共享
var sem = new SemaphoreSlim(3);
await Task.WhenAll(items.Select(async x =>
{
    await sem.WaitAsync(ct);
    try { await ProcessAsync(x, ct); }
    finally { sem.Release(); }        // finally 必须有，否则一次异常就永久少一个名额
}));

// 12 个 100ms 任务、并发 3 → 432 ms（理论下限 400 ms）

// 独立操作并发做：从串行到并发只改一行
var userTask   = _db.FindUserAsync(id, ct);
var ordersTask = _db.FindOrdersAsync(id, ct);
var statsTask  = _http.GetStatsAsync(id, ct);

await Task.WhenAll(userTask, ordersTask, statsTask);
return new Dashboard(userTask.Result, ordersTask.Result, statsTask.Result);
// ↑ WhenAll 之后取 .Result 是安全的：任务已确定完成

// 有返回值的批量并发（注意：这里没有限流！）
var results = await Task.WhenAll(ids.Select(i => FetchAsync(i, ct)));

// 带限流 + 收集结果的完整写法
var bag = new ConcurrentBag<Result>();      // 并发写要用并发集合
await Parallel.ForEachAsync(ids,
    new ParallelOptions { MaxDegreeOfParallelism = 8, CancellationToken = ct },
    async (id, token) => bag.Add(await FetchAsync(id, token)));

// 竞速 + 取消落败者
using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
var t1 = FetchFromPrimaryAsync(cts.Token);
var t2 = FetchFromMirrorAsync(cts.Token);
var done = await Task.WhenAny(t1, t2);
await cts.CancelAsync();                   // 让另一个尽快收工
return await done;

var t1 = Task.Run(() => throw new InvalidOperationException("A"));
var t2 = Task.Run(() => throw new ArgumentException("B"));
var all = Task.WhenAll(t1, t2);

try { await all; }
catch (Exception e) { }        // 只抓到 InvalidOperationException: A

all.Exception!.InnerExceptions.Count      // 2 —— 另一个在这里

using var cts = new CancellationTokenSource(100);   // 100ms 后自动取消
try { await Task.Delay(5000, cts.Token); }
catch (OperationCanceledException e)
{
    // TaskCanceledException: A task was canceled.
}

// 每个任务自己兜住异常，最后统一看结果
var results = await Task.WhenAll(ids.Select(async id =>
{
    try { return Result<Data>.Ok(await FetchAsync(id, ct)); }
    catch (OperationCanceledException) { throw; }        // 取消要放行
    catch (Exception e) { return Result<Data>.Fail(e.Message); }
}));

var failed = results.Where(r => !r.Success).ToList();    // 每一个失败都看得见

// 取消令牌一路传递 + 主动检查
public async Task SyncAllAsync(CancellationToken ct)
{
    foreach (var batch in batches)
    {
        ct.ThrowIfCancellationRequested();               // 循环里主动检查
        await ProcessAsync(batch, ct);                     // 继续往下传
    }
}

// 合并"外部取消"与"自己的超时"
using var linked = CancellationTokenSource.CreateLinkedTokenSource(ct);
linked.CancelAfter(TimeSpan.FromSeconds(30));
await LongRunningAsync(linked.Token);

// ASP.NET Core：取消令牌直接作为 handler 参数注入（17 章）
// app.MapGet("/x", async (CancellationToken ct) => await SvcAsync(ct));

// 在 UI 线程（或老 ASP.NET 的请求线程）上：
var result = GetDataAsync().Result;      // ① UI 线程阻塞在这里

async Task<string> GetDataAsync()
{
    var r = await _http.GetStringAsync(url);   // ② 完成后要回到 UI 线程执行续体
    return r.Trim();                           // ③ 但 UI 线程正卡在 ① 上 → 互等
}

// ✗ 死锁的典型现场（WPF / WinForms / 老 ASP.NET）
private void Button_Click(object s, EventArgs e)
{
    var data = LoadAsync().Result;      // 卡死
}

// ✓ 事件处理器是 async void 的唯一正当用途
private async void Button_Click(object s, EventArgs e)
{
    try
    {
        var data = await LoadAsync();      // 不阻塞 UI 线程
        _label.Text = data;
    }
    catch (Exception ex)                  // 必须自己兜住：async void 的异常没人接得住
    {
        ShowError(ex);
    }
}

// ✓ 类库代码：全程 ConfigureAwait(false)
public async Task<string> FetchAsync(string url, CancellationToken ct)
{
    using var resp = await _http.GetAsync(url, ct).ConfigureAwait(false);
    resp.EnsureSuccessStatusCode();
    return await resp.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
}

// 唯一可以阻塞的地方：程序入口（而顶级语句里可以直接 await，连这个都不需要）
static int Main(string[] args) => RunAsync(args).GetAwaiter().GetResult();