Question

我想比较两个二进制文件。其中一个已经存储在服务器上，并且在我最初存储它时，在数据库中预先计算了CRC32。

我知道如果CRC不同，那么文件肯定是不同的。但是，如果CRC是相同的，我不知道文件是什么。所以，我正在寻找一种比较两个流的有效方法：一个来自发布的文件，另一个来自文件系统。

我不是溪流方面的专家，但我很清楚，就内存使用而言，我可以轻松地在这里拍摄自己。

Answer 1

static bool FileEquals(string fileName1, string fileName2)
{
    // Check the file size and CRC equality here.. if they are equal...    
    using (var file1 = new FileStream(fileName1, FileMode.Open))
        using (var file2 = new FileStream(fileName2, FileMode.Open))
            return FileStreamEquals(file1, file2);
}

static bool FileStreamEquals(Stream stream1, Stream stream2)
{
    const int bufferSize = 2048;
    byte[] buffer1 = new byte[bufferSize]; //buffer size
    byte[] buffer2 = new byte[bufferSize];
    while (true) {
        int count1 = stream1.Read(buffer1, 0, bufferSize);
        int count2 = stream2.Read(buffer2, 0, bufferSize);

        if (count1 != count2)
            return false;

        if (count1 == 0)
            return true;

        // You might replace the following with an efficient "memcmp"
        if (!buffer1.Take(count1).SequenceEqual(buffer2.Take(count2)))
            return false;
    }
}

Answer 2

我通过在读取流块上的循环中使用Int64比较来加速“memcmp”。这减少了约1/4的时间。

    private static bool StreamsContentsAreEqual(Stream stream1, Stream stream2)
    {
        const int bufferSize = 2048 * 2;
        var buffer1 = new byte[bufferSize];
        var buffer2 = new byte[bufferSize];

        while (true)
        {
            int count1 = stream1.Read(buffer1, 0, bufferSize);
            int count2 = stream2.Read(buffer2, 0, bufferSize);

            if (count1 != count2)
            {
                return false;
            }

            if (count1 == 0)
            {
                return true;
            }

            int iterations = (int)Math.Ceiling((double)count1 / sizeof(Int64));
            for (int i = 0; i < iterations; i++)
            {
                if (BitConverter.ToInt64(buffer1, i * sizeof(Int64)) != BitConverter.ToInt64(buffer2, i * sizeof(Int64)))
                {
                    return false;
                }
            }
        }
    }

Answer 3

如果您不想依赖crc，我会这样做：

    /// <summary>
    /// Binary comparison of two files
    /// </summary>
    /// <param name="fileName1">the file to compare</param>
    /// <param name="fileName2">the other file to compare</param>
    /// <returns>a value indicateing weather the file are identical</returns>
    public static bool CompareFiles(string fileName1, string fileName2)
    {
        FileInfo info1 = new FileInfo(fileName1);
        FileInfo info2 = new FileInfo(fileName2);
        bool same = info1.Length == info2.Length;
        if (same)
        {
            using (FileStream fs1 = info1.OpenRead())
            using (FileStream fs2 = info2.OpenRead())
            using (BufferedStream bs1 = new BufferedStream(fs1))
            using (BufferedStream bs2 = new BufferedStream(fs2))
            {
                for (long i = 0; i < info1.Length; i++)
                {
                    if (bs1.ReadByte() != bs2.ReadByte())
                    {
                        same = false;
                        break;
                    }
                }
            }
        }

        return same;
    }

Answer 4

如果你将那个crc更改为sha1签名，那么它的不同但具有相同签名的可能性是天文数字

Answer 5

您可以在检查CRC之前检查两个文件的长度和日期，以避免CRC检查。

但是如果你必须比较整个文件内容，我看到的一个巧妙的技巧是读取步幅中的字节数等于CPU的位数。例如，在32位PC上，一次读取4个字节，并将它们作为int32进行比较。在64位PC上，您可以一次读取8个字节。这大约是逐字节执行速度的4或8倍。你也可能想要使用一个不安全的代码块，这样你就可以使用指针而不是做一堆位移和OR'ing来将字节转换为原生的int大小。

您可以使用IntPtr.Size来确定当前处理器体系结构的理想大小。

Answer 6

接受的答案有一个指出的错误，但从未纠正：流读取调用不能保证返回所有请求的字节。

保证

BinaryReader ReadBytes 调用返回所请求的字节数，除非首先到达流的末尾。

以下代码利用 BinaryReader 进行比较：

    static private bool FileEquals(string file1, string file2)
    {
        using (FileStream s1 = new FileStream(file1, FileMode.Open, FileAccess.Read, FileShare.Read))
        using (FileStream s2 = new FileStream(file2, FileMode.Open, FileAccess.Read, FileShare.Read))
        using (BinaryReader b1 = new BinaryReader(s1))
        using (BinaryReader b2 = new BinaryReader(s2))
        {
            while (true)
            {
                byte[] data1 = b1.ReadBytes(64 * 1024);
                byte[] data2 = b2.ReadBytes(64 * 1024);
                if (data1.Length != data2.Length)
                    return false;
                if (data1.Length == 0)
                    return true;
                if (!data1.SequenceEqual(data2))
                    return false;
            }
        }
    }

比较C＃中的二进制文件

6 个答案: