Bdtjtk

I am learning the MD5 hash values of the files through the code I have provided below. However, as the file size grows, the calculation takes a long time as well. I want to reflect this calculation on a progress bar object, but I have no idea.

I want something like this;

progressBar.Value = mD5.ComputedBytes;

progressBar.Maximum = mD5.TotalBytesToCompute;

How to make this?

Code;

public static string getMD5HashFromFile(string fileName)

{

    string str = "";

    using (MD5 mD5 = MD5.Create())

    {

        using (FileStream fileStream = File.OpenRead(fileName))

        { str = BitConverter.ToString(mD5.ComputeHash(fileStream)).Replace("-", string.Empty); fileStream.Close(); }

    }

    return str;

}

HashAlgorithm gives you the ability to hash data in chunks using TransformBlock and TransformFinalBlock methods. In the other hand, Stream class also allows you to read data in chunks asynchronously.

Considering these facts, you can create a method to get a stream as input and then read stream in chunks and then for each chuck hash it and report the progress (number of bytes processes) by calculating bytes read.

ComputeHashAsync

Here I've created a ComputeHashAsync extension method for HashAlgorithm class. It accepts:

• 
  stream: input Stream to compute hash.


• 
  cancellationToken: an optional CancellationToken which can be used to cancel the operation


• 
  progress: an optional instance of IProgress<long> which receives the progress report (number of bytes processed).


• 
  buggerSize: an optional buffer size for reading data. The default id 1024*1024 bytes.

Here is the code:

using System;

using System.IO;

using System.Security.Cryptography;

using System.Threading;

using System.Threading.Tasks;

public static class HashAlgorithmExtensions {

    public static async Task<byte> ComputeHashAsync(

        this HashAlgorithm hashAlgorithm, Stream stream,

        CancellationToken cancellationToken = default(CancellationToken),

        IProgress<long> progress = null,

        int bufferSize = 1024 * 1024) {

        byte readAheadBuffer, buffer, hash;

        int readAheadBytesRead, bytesRead;

        long size, totalBytesRead = 0;

        size = stream.Length;

        readAheadBuffer = new byte[bufferSize];

        readAheadBytesRead = await stream.ReadAsync(readAheadBuffer, 0, 

           readAheadBuffer.Length, cancellationToken);

        totalBytesRead += readAheadBytesRead;

        do {

            bytesRead = readAheadBytesRead;

            buffer = readAheadBuffer;

            readAheadBuffer = new byte[bufferSize];

            readAheadBytesRead = await stream.ReadAsync(readAheadBuffer, 0,

                readAheadBuffer.Length, cancellationToken);

            totalBytesRead += readAheadBytesRead;



            if (readAheadBytesRead == 0)

                hashAlgorithm.TransformFinalBlock(buffer, 0, bytesRead);

            else

                hashAlgorithm.TransformBlock(buffer, 0, bytesRead, buffer, 0);

            if (progress != null)

                progress.Report(totalBytesRead);

            if (cancellationToken.IsCancellationRequested)

                cancellationToken.ThrowIfCancellationRequested();

        } while (readAheadBytesRead != 0);

        return hash = hashAlgorithm.Hash;

    }

}

Example 1 - Update ProgressBar

byte bytes;

using (var hash = MD5.Create())

{

    using (var fs = new FileStream(f, FileMode.Open))

    {

        bytes = await hash.ComputeHashAsync(fs,

            progress: new Progress<long>(i =>

            {

                progressBar1.Invoke(new Action(() =>

                {

                    progressBar1.Value = i;

                }));

            }));

        MessageBox.Show(BitConverter.ToString(bytes).Replace("-", string.Empty));

    }

}

Example 2 - Cancelling task after 1 second

try

{

    var s = new CancellationTokenSource();

    s.CancelAfter(1000);

    byte bytes;

    using (var hash = MD5.Create())

    {

        using (var fs = new FileStream(f, FileMode.Open))

        {

            bytes = await hash.ComputeHashAsync(fs,

                cancellationToken: s.Token,

                progress: new Progress<long>(i =>

                {

                    progressBar1.Invoke(new Action(() =>

                    {

                        progressBar1.Value = i;

                    }));

                }));



            MessageBox.Show(BitConverter.ToString(bytes).Replace("-", string.Empty));

        }

    }

}

catch (OperationCanceledException)

{

    MessageBox.Show("Operation canceled.");

}

Creating a large file for test

var f = Path.Combine(Application.StartupPath, "temp.log");

File.Delete(f);

using (var fs = new FileStream(f, FileMode.Create))

{

    fs.Seek(1L * 1024 * 1024 * 1024, SeekOrigin.Begin);

    fs.WriteByte(0);

    fs.Close();

}

_{Note: The implementation of computing hash in chunks, is taken from a blog post by Alexandre Gomes, then I changed the code to make it async and support CancellationToken and IProgress<long>.}