File Comparison in C# – Part 3

In this third and final article of my File Comparison in C# series we will be creating a method which compares file hashes. I suggest you read File Comparison in C# – Part 1, and File Comparison in C# – Part 2 before continuing with this article, if you haven’t already done so.

What is a File Hash?

First of all a hash function is a mathematical function which converts a large sized amount of data into a much smaller datum. This datum is a representation of the actual large data, so it is ideal to use for data comparisons or database lookups for example.

So, a file hash would be the hash representation of a file. When you look at it, a hash is just a long numerical or alpha-numerical value, such as for example these two:
b7404b4dd5e4d1b67869226dcbc2da09
29-B4-1C-B3-54-F3-14-19-16-EE-0D-6A-F5-73-56-9F-DA-3F-D5-47

File Comparison using Hashes

To create our file comparison method we are going to use the .NET HashAlgorithm class. To use this class we need to add the System.Security.Cryptography namespace to our project.

The below code is an example of a file hash comparison method:

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;
    }
}

This method accepts two parameters, which are the full file names of the files we want to compare. In the first line of code we are calling the CompareFileSizes method we created in part 1 of this article. Next we are initialising the HashAlgorithm class which will be used to generate our file hashes. We are also declaring two byte arrays which will be used to store the file hashes. Next we are creating two FileStream objects for each of the files we passed as parameters, and finally we are using the ComputeHash method of the HashAlgorithm class to compute our file hashes. This method returns true if the hashes match and false if they don’t.

How accurate is this method?

The chances of generating two identical hashes for different files is almost impossible. A tiny change in a file results in a fairly large and unpredictable change in the generated hash. During my entire software development career, I have never encountered equal hashes for different values/files. Although having said this, it is still technically possible to generate equal hashes for different files but it is so rare that it is not something to worry about when working with hashes.

So which comparison technique is the best?

To find out I compared small and large files using the byte by byte comparison, and the file hash comparison methods we created, and I timed them. Below are the results:

As you can see from the results, there is practically no difference between the comparison methods for small files, but when I compared two large files of around 700MB each you can clearly see a difference between the methods. The byte by byte method took around 27 seconds to complete comparing the large files, while the file hash comparison method took around 18 seconds to complete.

This comparison clearly shows that the file hash method is quicker, and given the almost impossible chances of generating equal hashes for different files, I would say that the accuracy of this method is basically the same as that of the byte by byte method.

Therefore, if I was creating a comparison method, I would go for the file hash comparison technique 🙂

I hope you found this article series interesting. Feel free to leave any comments or if you want you can contact me through my contact page.

Happy comparing…
Dave