如何以ReadOnlySpan<byte>读取文件供SpanReader<byte>使用？

你的当前方案用File.ReadAllBytes会一次性将整个文件加载到内存，对于大文件会造成不必要的内存分配和GC压力，核心优化方向是改用流式分块读取+SpanReader结合，既保留SpanReader的高性能，又控制内存占用。

核心优化思路 #

避免一次性加载全量文件，改用FileStream配合池化缓冲区或栈分配缓冲区，分块读取文件内容，每次只处理一小块数据；同时需要处理跨块的数据结构（比如某个字段刚好落在两块缓冲区的边界），保留未处理的剩余数据到下一轮循环合并处理。

具体实现方案 #

1. 大文件首选：ArrayPool池化缓冲（低分配、可控内存） #

用ArrayPool<byte>复用缓冲区数组，避免频繁创建销毁数组，适合任意大小的文件：

using var fs = new FileStream(emfFile, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 4096);
var buffer = ArrayPool<byte>.Shared.Rent(4096); // 缓冲大小选系统扇区倍数（4096/8192）
ReadOnlySpan<byte> remainingData = ReadOnlySpan<byte>.Empty;

try
{
    int bytesRead;
    while ((bytesRead = fs.Read(buffer)) > 0)
    {
        var currentChunk = buffer.AsSpan(0, bytesRead);
        ReadOnlySpan<byte> combinedBuffer;

        // 合并上一轮剩余的数据和当前读取的块
        if (remainingData.Length > 0)
        {
            // 临时租一个足够容纳剩余+当前块的缓冲
            var tempBuffer = ArrayPool<byte>.Shared.Rent(remainingData.Length + currentChunk.Length);
            try
            {
                remainingData.CopyTo(tempBuffer);
                currentChunk.CopyTo(tempBuffer.AsSpan(remainingData.Length));
                combinedBuffer = tempBuffer.AsSpan(0, remainingData.Length + currentChunk.Length);
            }
            finally
            {
                ArrayPool<byte>.Shared.Return(tempBuffer);
            }
        }
        else
        {
            combinedBuffer = currentChunk;
        }

        var reader = new DotNext.Buffers.SpanReader<byte>(combinedBuffer);
        // 循环处理数据，直到剩余的字节不足以读取下一个完整结构
        while (HasEnoughBytesForNextStructure(reader)) // 自定义判断逻辑：比如检查剩余字节数是否大于等于要读取的结构大小
        {
            // 示例：读取EMF文件的字段
            var headerSize = reader.ReadInt32();
            var recordType = reader.ReadUInt16();
            // 其他读取操作...
        }

        // 保存未处理的剩余数据，用于下一轮合并
        remainingData = reader.RemainingSpan.ToArray().AsSpan(); // 仅在剩余数据量小时分配，影响可忽略
    }

    // 处理最后剩余的少量数据
    if (!remainingData.IsEmpty)
    {
        var finalReader = new DotNext.Buffers.SpanReader<byte>(remainingData);
        ProcessRemainingData(finalReader); // 自定义处理逻辑
    }
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer);
}

2. 小文件优化：保留原方案（简单高效） #

如果你的场景中文件都是几MB以内的小文件，File.ReadAllBytes的分配成本极低，代码简洁性反而更重要，完全可以保留原方案：

ReadOnlySpan<byte> ros = File.ReadAllBytes(emfFile).AsSpan();
using var spreader = new DotNext.Buffers.SpanReader<byte>(ros);
// 后续读取操作...

3. 栈分配缓冲（极致低分配，适合固定小结构） #

如果读取的文件结构固定、单块数据量小，可以用stackalloc分配栈上缓冲，完全避免堆分配，但要注意栈空间有限（通常几MB），需控制缓冲大小：

using var fs = new FileStream(emfFile, FileMode.Open, FileAccess.Read);
stackalloc byte buffer[4096];
ReadOnlySpan<byte> remainingData = ReadOnlySpan<byte>.Empty;

int bytesRead;
while ((bytesRead = fs.Read(buffer)) > 0)
{
    var currentChunk = buffer.AsSpan(0, bytesRead);
    // 处理剩余数据与当前块的合并（需注意栈空间是否足够，溢出时 fallback 到池化缓冲）
    if (remainingData.Length + currentChunk.Length > buffer.Length)
    {
        // 栈空间不足，临时用池化缓冲处理
        var tempBuffer = ArrayPool<byte>.Shared.Rent(remainingData.Length + currentChunk.Length);
        try
        {
            remainingData.CopyTo(tempBuffer);
            currentChunk.CopyTo(tempBuffer.AsSpan(remainingData.Length));
            ProcessChunk(tempBuffer.AsSpan(0, remainingData.Length + currentChunk.Length));
        }
        finally
        {
            ArrayPool<byte>.Shared.Return(tempBuffer);
        }
    }
    else
    {
        remainingData.CopyTo(buffer);
        currentChunk.CopyTo(buffer.AsSpan(remainingData.Length));
        ProcessChunk(buffer.AsSpan(0, remainingData.Length + currentChunk.Length));
    }

    // 这里的ProcessChunk内部会创建SpanReader并处理数据，返回剩余未处理的Span
    remainingData = GetRemainingDataFromProcessedChunk();
}

关键优化细节 #

• 缓冲大小选择：用4096或8192字节，与系统磁盘扇区大小匹配，提升读取效率
• 跨块数据处理：必须保留每轮处理后的剩余Span，合并到下一轮的缓冲中，避免数据截断
• 异步适配：如果是IO密集型场景，可改用FileStream.ReadAsync配合Memory<byte>，读取后转成Span<byte>再处理
• 异常处理：在读取和处理过程中，需添加针对文件损坏、数据不完整的异常捕获逻辑

内容的提问来源于stack exchange，提问作者juFo