C#中如何快速重写文件字节？大文件性能优化求助

你的问题核心在于一次性加载超大文件到内存后处理的IO与内存效率瓶颈，700MB文件耗时6分钟确实超出合理范围，我们可以从IO方式优化和内存操作效率提升两个方向入手，轻松把耗时压到1分钟以内。

先拆解原代码的潜在问题：

• File.ReadAllBytes 和 File.WriteAllBytes 会一次性把整个文件加载到内存，不仅占用大量内存（700MB数组），单次IO的磁盘开销也极大，尤其是写入时需要一次性刷入所有数据。
• 虽然循环逻辑本身没问题，但大内存数组的遍历可能会出现缓存命中率下降的情况，间接拖慢处理速度。

下面按推荐程度给出优化方案：

方案1：使用内存映射文件（MemoryMappedFile） #

这是最推荐的方案，它直接将文件映射到进程的内存空间，操作内存就等同于操作文件，无需显式读取/写入整个文件，性能提升非常显著。

Span优化版（推荐） #

static private void Optimized_12_56_Span(string fileName)
{
    using var mmf = MemoryMappedFile.CreateFromFile(fileName, FileMode.Open, null, 0, MemoryMappedFileAccess.ReadWrite);
    using var viewAccessor = mmf.CreateViewAccessor(0, 0, MemoryMappedFileAccess.ReadWrite);
    long fileLength = new FileInfo(fileName).Length;
    long totalBlocks = fileLength / 6;

    for (long i = 0; i < totalBlocks; i++)
    {
        long offset = i * 6;
        // 直接获取Span，减少多次IO调用
        Span<byte> block = stackalloc byte[6];
        viewAccessor.ReadArray(offset, block, 0, 6);

        // 执行字节交换
        (block[0], block[4]) = (block[4], block[0]);
        (block[1], block[5]) = (block[5], block[1]);

        viewAccessor.WriteArray(offset, block, 0, 6);
    }
}

方案2：分块读取+写入临时文件 #

如果不想用内存映射，分块处理可以大幅降低内存占用，同时利用磁盘IO的缓存机制，避免一次性加载大文件的开销。

static private void Chunked_12_56(string fileName)
{
    string tempFileName = Path.GetTempFileName();
    const int chunkSize = 6 * 1024 * 1024; // 6MB块大小（可根据系统内存调整）

    using var sourceStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.None, chunkSize, FileOptions.SequentialScan);
    using var targetStream = new FileStream(tempFileName, FileMode.Create, FileAccess.Write, FileShare.None, chunkSize, FileOptions.SequentialScan);

    byte[] buffer = new byte[chunkSize];
    int bytesRead;

    while ((bytesRead = sourceStream.Read(buffer, 0, buffer.Length)) > 0)
    {
        // 处理完整的6字节块
        int fullBlocks = bytesRead / 6;
        for (int i = 0; i < fullBlocks; i++)
        {
            int offset = i * 6;
            // 直接交换字节，省去Swap方法调用开销
            (buffer[offset], buffer[offset + 4]) = (buffer[offset + 4], buffer[offset]);
            (buffer[offset + 1], buffer[offset + 5]) = (buffer[offset + 5], buffer[offset + 1]);
        }

        // 写入处理后的完整块
        targetStream.Write(buffer, 0, fullBlocks * 6);

        // 处理剩余不足6字节的部分
        int remaining = bytesRead % 6;
        if (remaining > 0)
        {
            byte[] remainingBytes = new byte[remaining];
            Array.Copy(buffer, fullBlocks * 6, remainingBytes, 0, remaining);
            targetStream.Write(remainingBytes, 0, remaining);
        }
    }

    // 替换原文件
    sourceStream.Close();
    targetStream.Close();
    File.Delete(fileName);
    File.Move(tempFileName, fileName);
}

方案3：最小改动优化原数组操作 #

如果一定要保留原有的数组处理逻辑，至少做以下优化来提升效率：

static private void OptimizedOriginal_12_56(string fileName)
{
    byte[] byteArray = File.ReadAllBytes(fileName);
    int length = byteArray.Length;
    Span<byte> span = byteArray.AsSpan();

    // 用Length替代Count()，避免LINQ调用开销；用Span减少数组边界检查
    for (int i = 0; i <= length - 6; i += 6)
    {
        // 直接值交换，省去Swap方法的调用开销
        (span[i], span[i + 4]) = (span[i + 4], span[i]);
        (span[i + 1], span[i + 5]) = (span[i + 5], span[i + 1]);
    }

    File.WriteAllBytes(fileName, byteArray);
}

性能预期参考 #

• 原代码：700MB文件约6分钟
• 方案1（内存映射+Span）：预计10-30秒（取决于磁盘读写速度）
• 方案2（分块处理）：预计20-40秒
• 方案3：预计1-2分钟（若磁盘IO是核心瓶颈，提升效果有限）

注意：操作大文件前务必做好备份，避免意外损坏文件；内存映射文件需确保没有其他进程正在访问目标文件。

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