C# 读取文件：避免 Stream.Read 截断的稳健方案

C# 读取文件的常见误区

在 C# 中，文件流（FileStream）是处理文件输入的基础类。初学者往往容易陷入一种简化操作的陷阱：

1. 创建流实例：通过 File.OpenRead(filename) 或构造函数初始化。
   

   FileStream fs = File.OpenRead(filename);
   // 或者
   FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);

2. 分配内存空间：根据文件大小创建一个等长的字节数组。
   

   byte[] data = new byte[fs.Length];

3. 执行读取：调用一次 Read 方法尝试将数据填入数组。
   

   fs.Read(data, 0, data.Length);

这种写法看似简洁，但在大多数情况下无法保证读到所有字节。问题的核心在于对 Stream.Read 返回值理解的偏差。

核心原理：为什么不能只读一次？

Stream.Read(byte[] buffer, int offset, int count) 方法的定义是：从当前流中读取最多 count 个字节，并将数据写入 buffer 中的指定偏移位置。

关键点如下：

• 非阻塞与缓冲：对于网络流或大文件，底层 IO 驱动可能不会一次性将所有数据推送到位。该方法返回的是实际读取到的字节数，通常小于请求的数量。
• EOF 信号：只有当到达流的末尾且下一次读取无数据时，才可能返回 0。如果在中间状态只调用了单次 read，部分剩余字节会滞留在系统中，导致程序获得残缺数据。
• 安全性缺失：上述“三步法”完全忽略了返回值，属于无效编码模式。

第1步：使用循环确保读取完毕（固定缓冲区版）

目的：适用于已知总长度且可预分配的内存场景。通过轮询直到读完所有指定长度的字节。

关键逻辑：记录读取偏移量（offset）和剩余字节数（remaining），循环调用 Read 并更新这两个参数。

public static void SafeRead(Stream stream, byte[] data)
{
    int offset = 0;
    int remaining = data.Length;

    while (remaining > 0)
    {
        // 尝试读取剩余的字节
        int read = stream.Read(data, offset, remaining);
        
        // 如果读取结果 <= 0，说明发生错误或到达意外结束
        if (read <= 0) throw new EndOfStreamException("文件读取失败");
        
        remaining -= read;
        offset += read;
    }
}

第2步：处理未知长度的流（动态缓冲区版）

目的：在处理网络流（如 HTTP Response 下载）时，有时无法预先知道内容大小。此方法利用 MemoryStream 自动扩容的特性。

入口：传入任意类型的 Stream。

public static byte[] ReadFully(Stream stream)
{
    // 使用较小的块大小读取，避免占用过多峰值内存
    byte[] buffer = new byte[32768];
    using (MemoryStream ms = new MemoryStream())
    {
        while (true)
        {
            int read = stream.Read(buffer, 0, buffer.Length);
            if (read <= 0) return ms.ToArray();
            ms.Write(buffer, 0, read);
        }
    }
}

第3步：手动管理 Buffer 的高效读写（进阶版）

目的：减少对象复制开销，在不依赖额外托管容器（如 MemoryStream）的情况下，手动管理数组扩容。

步骤动作：

1. 初始化一个初始容量的 Buffer。
2. 循环调用 Read，累加读取计数。
3. 检测是否填满 Buffer。若已满，再次读取一个字节以判断流是否彻底关闭。
4. 扩容新数组并拷贝旧数据。

public static byte[] Read2Buffer(Stream stream, int BufferLen)
{
    if (BufferLen < 1) BufferLen = 0x8000;
    
    byte[] buffer = new byte[BufferLen];
    int read = 0;
    int block;

    while ((block = stream.Read(buffer, read, buffer.Length - read)) > 0)
    {
        read += block;
        
        // 检查是否到达了缓存的边界
        if (read == buffer.Length)
        {
            // 尝试读取一个字节来探测是否还有后续数据
            int nextByte = stream.ReadByte();
            if (nextByte == -1) return buffer;
            
            // 调整数组大小（此处演示翻倍扩容策略）
            byte[] newBuf = new byte[buffer.Length * 2];
            Array.Copy(buffer, newBuf, buffer.Length);
            newBuf[read] = (byte)nextByte;
            buffer = newBuf;
            read++;
        }
    }
    
    // 最后一步：裁剪多余预留的数组部分，精确匹配实际读取量
    byte[] ret = new byte[read];
    Array.Copy(buffer, ret, read);
    return ret;
}

总结与最佳实践建议

虽然上述方法展示了底层的处理逻辑，但在现代 C# 开发中，更推荐直接封装好的工具类以降低复杂度：

• 小文件读取：直接使用 File.ReadAllBytes(path) 或 File.ReadAllText(path)。
• 大文件或流式处理：优先使用异步方法 CopyToAsync 进行管道传输，而不是在内存中构建巨大的字节数组。例如：sourceStream.CopyToAsync(targetStream)。
• 安全释放资源：在使用完 Stream 对象后，务必使用 using 语句包裹或在 finally 块中调用 Dispose()，防止文件句柄泄漏。

以上就是 C# 读取文件详谈的详细内容，更多关于 C# 高效 IO 处理的资料请关注本站其它相关文章！