性能剖析与调优

调优闭环：
  1. 建立基准（Benchmark）    ← 可重复测量
  2. 剖析定位（CPU/内存/GC）  ← 找到热点
  3. 假设归因（分配？算法？IO）
  4. 优化实施（小步改动）
  5. 回测验证（对比前后数据）
  6. 复盘沉淀（写入知识库）

[MemoryDiagnoser]        // 额外统计分配量
public class ConcatBenchmark
{
    private readonly string _a = "alpha";
    private readonly string _b = "beta";

    [Benchmark(Baseline = true)]
    public string WithPlus() => _a + "-" + _b;

    [Benchmark]
    public string WithInterpolate() => $"{_a}-{_b}";

    [Benchmark]
    public string WithStringBuilder()
    {
        var sb = new StringBuilder();
        sb.Append(_a).Append('-').Append(_b);
        return sb.ToString();
    }
}

// 运行结果（示例）：
// | Method            | Mean     | Allocated |
// | WithPlus          | 18.4 ns  | 48 B      |
// | WithInterpolate   | 18.6 ns  | 48 B      |
// | WithStringBuilder | 28.1 ns  | 96 B      |

# 实时查看 GC 与分配计数器
dotnet-counters monitor --process-id 1234 System.Runtime

# 采集分配追踪（.nettrace 可用 PerfView/VS 分析）
dotnet-trace collect --process-id 1234 --profile gc-verbose

// 装箱热点：值类型被塞进非泛型容器
// object o = x;            ← 每次装箱分配一个对象

// 分配热点：高频路径上频繁 new
public string FormatKey(int a, int b)
{
    // 每次调用分配多个字符串
    return string.Format("{0}-{1}", a, b);
}

// 优化：避免格式化的分配，用栈缓冲
public string FormatKeyFast(int a, int b)
{
    Span<char> buffer = stackalloc char[32];
    int len = $"{a}-{b}".AsSpan().Length;      // 简化示例
    return new string(buffer[..len]);
}

// 数组池：复用缓冲，避免频繁大分配
private static readonly ArrayPool<byte> Pool = ArrayPool<byte>.Shared;

public byte[] ReadChunk(Stream stream, int size)
{
    byte[] buffer = Pool.Rent(size);          // 池中租借
    try
    {
        int read = stream.Read(buffer, 0, size);
        return buffer.AsSpan(0, read).ToArray();
    }
    finally
    {
        Pool.Return(buffer);                  // 归还，必须成对
    }
}

// 栈上解析数字：不产生字符串分配
public static int ParseFast(ReadOnlySpan<char> text)
{
    int result = 0;
    foreach (char c in text)
    {
        if (c is < '0' or > '9') break;
        result = result * 10 + (c - '0');
    }
    return result;
}

// 运行时观察 JIT 行为
// DOTNET_TieredCompilation=1        ← 默认开启
// DOTNET_TieredCompilation=0        ← 关闭（仅诊断）
// DOTNET_ReadyToRun=1               ← R2R 预编译，加快启动
// DOTNET_TC_QuickJitForLoops=1      ← 循环快速 JIT

// 预热：基准测试与压测都必须先热身
public static void Warmup()
{
    // 让热路径跑起来，触发 Tier1 替换
    _ = ParseFast("12345".AsSpan());
    _ = ParseFast("67890".AsSpan());
}

// 反面：O(n²) 的列表查找
public string? FindSlow(List<Order> orders, int id)
{
    foreach (var o in orders)
    {
        if (o.Id == id) return o.Customer;      // 每次线性扫描
    }
    return null;
}

// 优化：建立索引字典，O(1) 查找
public string? FindFast(Dictionary<int, string> index, int id)
{
    return index.TryGetValue(id, out var c) ? c : null;
}

// 剖析输出（示例）
// 方法            调用次数   自耗时占比
// FindSlow        10000      68%
// SaveChanges     10000      21%
// 序列化          20000      8%

dotnet-counters：Gen0 回收每秒 40+ 次，分配率 80 MB/s
dotnet-trace：   OrderService.BuildReport 占 61%，OrderRepository 查询占 22%
Benchmark：      循环中访问 order.Customer 触发 N+1，单次 180 条查询

// 1. 贪婪加载 + 投影：一次 SQL 拿全
var data = await db.Orders
    .Where(o => o.CreatedAt > since)
    .Select(o => new { o.Id, o.Total, o.Customer!.Name })
    .ToListAsync();

// 2. 预聚合：字典归并，避免二次循环查询
var totals = data
    .GroupBy(x => x.Name)
    .ToDictionary(g => g.Key, g => g.Sum(x => x.Total));

// 3. StringBuilder 拼接报表，避免中间字符串
var sb = new StringBuilder();
foreach (var (name, total) in totals)
{
    sb.Append(name).Append(": ").Append(total).AppendLine();
}