Problem with comparing 2 files - false when should be true?

I tried using byte by byte comparison and also comparing calculated hash of files (code samples below). I have a file, copy it - compare both - result is TRUE. But problem starts when I open one of the files:

With MS word files - after opening and closing one of files, result is still TRUE, but, for example, when I delete last symbol in file, then write it back again, and then try to compare again - result FALSE. Files are basically the same, bet theoretically it seems that in byte-by-byte they are not the same anymore.

With Excel files - even opening a file causes function to return false. Should it really be like that? Only thing that I can think of that has changed is Last Access time. But does it takes into consideration when comparing byte-by-byte?

So I wanted to ask, does this comparison really should work like this, and is there anything I could do to evade this? In my program I will compare mostly.pdf files, where editing won't be much of an option, but I still wanted to know why is it acting like this.

Byte-by-Byte with buffer:

static bool FilesAreEqualFaster(string f1, string f2)
    {
        // get file length and make sure lengths are identical
        long length = new FileInfo(f1).Length;
        if (length != new FileInfo(f2).Length)
            return false;

        byte[] buf1 = new byte[4096];
        byte[] buf2 = new byte[4096];

        // open both for reading
        using (FileStream stream1 = File.OpenRead(f1))
        using (FileStream stream2 = File.OpenRead(f2))
        {
            // compare content for equality
        开发者_Python百科    int b1, b2;
            while (length > 0)
            {
                // figure out how much to read
                int toRead = buf1.Length;
                if (toRead > length)
                    toRead = (int)length;
                length -= toRead;

                // read a chunk from each and compare
                b1 = stream1.Read(buf1, 0, toRead);
                b2 = stream2.Read(buf2, 0, toRead);
                for (int i = 0; i < toRead; ++i)
                    if (buf1[i] != buf2[i])
                        return false;
            }
        }

        return true;
    }

Hash:

private static bool CompareFileHashes(string fileName1, string fileName2)
    {
        // Compare file sizes before continuing.
        // If sizes are equal then compare bytes.
        if (CompareFileSizes(fileName1, fileName2))
        {
            // Create an instance of System.Security.Cryptography.HashAlgorithm
            HashAlgorithm hash = HashAlgorithm.Create();

            // Declare byte arrays to store our file hashes
            byte[] fileHash1;
            byte[] fileHash2;

            // Open a System.IO.FileStream for each file.
            // Note: With the 'using' keyword the streams
            // are closed automatically.
            using (FileStream fileStream1 = new FileStream(fileName1, FileMode.Open),
                              fileStream2 = new FileStream(fileName2, FileMode.Open))
            {
                // Compute file hashes
                fileHash1 = hash.ComputeHash(fileStream1);
                fileHash2 = hash.ComputeHash(fileStream2);
            }

            return BitConverter.ToString(fileHash1) == BitConverter.ToString(fileHash2);
        }
        else
        {
            return false;
        }
    }

Aside from anything else, this code is wrong:

b1 = stream1.Read(buf1, 0, toRead);
b2 = stream2.Read(buf2, 0, toRead);
for (int i = 0; i < toRead; ++i)
    if (buf1[i] != buf2[i])
        return false;

You're ignoring the possibility of b1 and b2 being unequal to each other and to toRead. What if you only read 10 bytes from the first stream and 20 from the second, when you asked for 30? You may not have reached the end of the files, but it can still potentially return you less data than you ask for. Never ignore the return value of Stream.Read. (You're saving it in a variable but then ignoring the variable.)

Basically you'll need to have independent buffers, which are replenished when necessary - keep track of where you are within each buffer, and how much useful data is there. Read more data into each buffer when you need to.

Then there's the other problem of files actually changing just by opening them, as Henk mentioned.