如何在C#中修复拷贝文件的损坏数据包（非重拷贝方案）

Great question! The short answer is yes, you can repair only the corrupted blocks instead of re-copying the entire file—but it depends on one critical requirement: you need to have precomputed hashes for individual data blocks (not just a single hash for the entire file). Here's how it works, step by step:

Key Pre-Requisite: Block-Level Hashing #

A single MD5/CRC32 hash for the entire file only tells you that the file is corrupted, not where the corruption happened. To target specific blocks, you must:

• Split the source file into fixed-size data blocks (e.g., 1MB, 5MB—adjust based on your use case)
• Compute a hash (CRC32 is ideal for speed, MD5 for slightly better collision resistance) for each block
• Store this list of block hashes alongside the file (or transmit it with the file copy)

How to Implement the Repair Workflow in C# #

1. Precompute Block Hashes for the Source File #

First, generate and save the hash list for your source file. CRC32 is preferred here because it’s much faster than MD5/SHA algorithms, which is perfect for routine integrity checks.

Note: .NET doesn’t include a built-in CRC32 class, so you can either implement it yourself or use a lightweight NuGet package like Crc32.NET or System.Data.HashFunction.CRC.

using System.IO;
using System.Collections.Generic;
using Crc32.NET; // Example NuGet package

public static List<string> GenerateBlockHashes(string sourceFilePath, int blockSize = 1024 * 1024)
{
    var blockHashes = new List<string>();
    
    using (var sourceStream = new FileStream(sourceFilePath, FileMode.Open, FileAccess.Read))
    {
        byte[] buffer = new byte[blockSize];
        int bytesRead;
        
        while ((bytesRead = sourceStream.Read(buffer, 0, blockSize)) > 0)
        {
            // Compute CRC32 hash for the current block
            uint crcHash = Crc32Algorithm.Compute(buffer, 0, bytesRead);
            blockHashes.Add(crcHash.ToString("X8")); // Convert to 8-character hex string
        }
    }
    
    return blockHashes;
}

2. Detect Corrupted Blocks in the Copied File #

Next, compute block hashes for the copied file and compare them against the source’s hash list to identify which blocks are corrupted.

public static List<int> FindCorruptedBlocks(string targetFilePath, List<string> sourceBlockHashes, int blockSize = 1024 * 1024)
{
    var corruptedBlockIndices = new List<int>();
    var targetBlockHashes = GenerateBlockHashes(targetFilePath, blockSize);
    
    for (int i = 0; i < sourceBlockHashes.Count; i++)
    {
        if (targetBlockHashes[i] != sourceBlockHashes[i])
        {
            corruptedBlockIndices.Add(i);
        }
    }
    
    return corruptedBlockIndices;
}

3. Repair Only the Corrupted Blocks #

Once you know which blocks are bad, you can overwrite them with the correct data from the source file—no need to re-copy everything.

public static void RepairCorruptedBlocks(string sourceFilePath, string targetFilePath, List<int> corruptedBlockIndices, int blockSize = 1024 * 1024)
{
    using (var sourceStream = new FileStream(sourceFilePath, FileMode.Open, FileAccess.Read))
    using (var targetStream = new FileStream(targetFilePath, FileMode.Open, FileAccess.Write))
    {
        byte[] buffer = new byte[blockSize];
        
        foreach (int blockIndex in corruptedBlockIndices)
        {
            // Seek to the start of the corrupted block in both streams
            long blockStartPosition = (long)blockIndex * blockSize;
            sourceStream.Seek(blockStartPosition, SeekOrigin.Begin);
            targetStream.Seek(blockStartPosition, SeekOrigin.Begin);
            
            // Read the correct block from the source and write it to the target
            int bytesRead = sourceStream.Read(buffer, 0, blockSize);
            targetStream.Write(buffer, 0, bytesRead);
            targetStream.Flush();
            
            Console.WriteLine($"Successfully repaired block #{blockIndex}");
        }
    }
}

Important Notes #

• Block Size Selection: Choose a block size that balances overhead (smaller blocks = larger hash lists) and repair efficiency (larger blocks = more data to fix per corruption). 1MB–10MB is a sweet spot for most use cases.
• Handling Partial Final Blocks: The code above accounts for the last block being smaller than the fixed size by using bytesRead instead of writing the entire buffer.
• Hash Algorithm Choice: Use CRC32 for fast checks; switch to MD5/SHA-256 only if you need protection against intentional tampering (CRC32 is not cryptographically secure).
• No Block Hashes = No Targeted Repair: If you only have a single hash for the entire file, you can’t pinpoint corrupted blocks—you’ll have to re-copy the whole file.

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