Span、Memory 与高性能 IO

// 解析 "key=value;key2=value2"，全程零分配
public static int ParsePairs(ReadOnlySpan<char> input, Span<KeyValuePair<string, string>> output)
{
    int count = 0;
    while (!input.IsEmpty)
    {
        int sep = input.IndexOf('=');
        if (sep < 0) break;

        ReadOnlySpan<char> key = input[..sep];
        input = input[(sep + 1)..];

        int end = input.IndexOf(';');
        ReadOnlySpan<char> value = end < 0 ? input : input[..end];
        input = end < 0 ? ReadOnlySpan<char>.Empty : input[(end + 1)..];

        // 只有最终要留存时才分配字符串
        output[count++] = new KeyValuePair<string, string>(key.ToString(), value.ToString());
    }
    return count;
}

// 栈上缓冲：小数据完全不碰堆
Span<byte> buffer = stackalloc byte[256];
int written = Encoding.UTF8.GetBytes("hello", buffer);

// 切片不产生拷贝
ReadOnlySpan<byte> slice = buffer[..written];

// 异步读入 + 同步解析
public static async Task<int> ReadAndParseAsync(Stream stream, CancellationToken ct)
{
    // Memory<byte> 可以跨 await
    Memory<byte> buffer = new byte[4096];
    int read = await stream.ReadAsync(buffer, ct);

    // 同步段里用 Span 处理
    return CountLines(buffer.Span[..read]);
}

private static int CountLines(ReadOnlySpan<byte> data)
{
    int lines = 0;
    while (true)
    {
        int nl = data.IndexOf((byte)'\n');
        if (nl < 0) return lines + (data.IsEmpty ? 0 : 1);
        lines++;
        data = data[(nl + 1)..];
    }
}

// 从分段序列里读出一条以 \n 结尾的消息
public static bool TryReadLine(ref SequenceReader<byte> reader, out string line)
{
    line = string.Empty;
    if (!reader.TryReadTo(out ReadOnlySequence<byte> seq, (byte)'\n', advancePastDelimiter: true))
        return false;

    line = Encoding.UTF8.GetString(seq);   // 只在成行时才分配
    return true;
}

// 跨段读取定长整数（大端）
public static bool TryReadInt32(ref SequenceReader<byte> reader, out int value)
{
    if (reader.Remaining < 4) { value = 0; return false; }

    Span<byte> tmp = stackalloc byte[4];
    reader.TryCopyTo(tmp);
    reader.Advance(4);

    value = BinaryPrimitives.ReadInt32BigEndian(tmp);
    return true;
}

public static async Task ProcessLinesAsync(PipeReader reader, CancellationToken ct)
{
    while (true)
    {
        ReadResult result = await reader.ReadAsync(ct);
        ReadOnlySequence<byte> buffer = result.Buffer;

        SequencePosition consumed = buffer.Start;
        SequencePosition examined = buffer.End;

        try
        {
            if (TryParseMessages(ref buffer, out consumed, out examined, out var messages))
            {
                foreach (var msg in messages) await HandleAsync(msg, ct);
            }

            if (result.IsCompleted && buffer.IsEmpty) break;
        }
        finally
        {
            // 必须调用，否则管道不会回收内存
            reader.AdvanceTo(consumed, examined);
        }
    }
    await reader.CompleteAsync();
}

// 写入方
public static async Task WriteAsync(PipeWriter writer, CancellationToken ct)
{
    Span<byte> span = writer.GetSpan(64);          // 借用可写内存
    int written = Encoding.UTF8.GetBytes("PING\r\n", span);

    writer.Advance(written);                        // 声明写了多少
    FlushResult fr = await writer.FlushAsync(ct);   // 可能因背压等待

    if (fr.IsCompleted) { /* 读取方已关闭 */ }
}

// 数组池：避免每次都分配大缓冲
public static async Task<int> CopyAsync(Stream src, Stream dst, CancellationToken ct)
{
    byte[] buffer = ArrayPool<byte>.Shared.Rent(81920);
    try
    {
        int total = 0, read;
        while ((read = await src.ReadAsync(buffer.AsMemory(0, 81920), ct)) > 0)
        {
            await dst.WriteAsync(buffer.AsMemory(0, read), ct);
            total += read;
        }
        return total;
    }
    finally
    {
        // 必须归还；含敏感数据时 clearArray: true
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

// 对象池：复用 StringBuilder、序列化器、连接等昂贵对象
private static readonly ObjectPool<StringBuilder> Pool =
    new DefaultObjectPool<StringBuilder>(new StringBuilderPooledObjectPolicy());

public static string Build(IEnumerable<string> parts)
{
    StringBuilder sb = Pool.Get();
    try
    {
        foreach (var p in parts) sb.Append(p);
        return sb.ToString();
    }
    finally
    {
        Pool.Return(sb);   // 归还前策略会重置状态
    }
}

// 解析 "GET /api/orders?id=42 HTTP/1.1"
public static bool TryParseRequestLine(
    ReadOnlySpan<char> line,
    out string method, out string path, out string version)
{
    method = path = version = string.Empty;

    int s1 = line.IndexOf(' ');
    if (s1 <= 0) return false;

    int s2 = line[(s1 + 1)..].IndexOf(' ');
    if (s2 <= 0) return false;
    s2 += s1 + 1;

    ReadOnlySpan<char> m = line[..s1];
    ReadOnlySpan<char> p = line[(s1 + 1)..s2];
    ReadOnlySpan<char> v = line[(s2 + 1)..];

    // 只在这里分配
    method = m.ToString();
    path = p.ToString();
    version = v.ToString();
    return true;
}

// 陷阱 1：Span 逃逸（编译期就会拦住）
// private Span<byte> _field;          // 编译错误

// 陷阱 2：async 中跨 await 使用 Span（编译错误）
// async Task Bad() { Span<byte> s = stackalloc byte[8]; await Task.Yield(); Use(s); }

// 陷阱 3：假设 Rent 的数组是干净的
byte[] buf = ArrayPool<byte>.Shared.Rent(1024);
// buf 里可能是上一次的残留数据，必须先写入或清零

// 陷阱 4：忘记 Return，池退化
// 每次 Rent 都拿新数组，池形同虚设