MultiHash tool created

I've built a new tool to add to the Infix Technologies collection. This one may be a bit obscure to most, but to some of you it may be a real time saver. MultiHash creates MD5 hashes for single files, sets of files, directory trees, or even entire drives.

"So what," you ask? Have you ever downloaded ISO files for something like a Linux distribution and seen a big long string labelled "MD5 Hash" that looks something like this?

5DB1C92CA8900310863D08EFA698E958

This tool can be used to verify that what you downloaded is exactly what they say it is. If you calculate the hash on the ISO after downloading, and your hash is not an exact match for theirs, someone was naughty and modified the ISO without telling you.

Another use for this tool, albeit a fairly limited one, is for verification of duplicate sets of files. As an example, software escrow companies need to be given multiple identical copies of the data to be put into escrow. How do you verify that they are identical? You can do it a couple of different ways.

1. Build an MD5 hash for each file. This can be interesting if you happen to have 25000 files.
2. Build an MD5 hash for a zip file containing everything. These can get really big, but it gives you just one hash.

If you went with option 1, the problem is that you have a whole set of hashes to verify as identical. The trick with MultiHash is that it builds a text file which contains a descriptive header, and then includes every hash value and the file name associated with it. The fun part is that it calculates a hash for that file. In effect, it is a grand overall sum hash so you can verify that two large sets of files are identical without having to put them into a monstrous zip file first.

As a side note, this is my first real try at building an app which uses the publishing features in Microsoft's Visual Studio 2013. It seems to have done a good job, but it's a little too bare-bones. I ended up writing some custom tools to change the name of the installer, and to customize the generic install web page to match.

Here's what MultiHash looks like. Noting too special, other than I used MVVM in WPF. That made it easy to make things size dynamically.

Let me know what you think about MultiHash.

Shout out to EPPlus

I just have a quick shout-out to someone who doesn't know they helped me out with a project. I needed a way to generate an Excel spreadsheet from inside a c# application. My client for the project wanted something more detailed and more usable than a .csv export file, because the single page of data was, to use the database lingo, not normalized. I had data repeated all over the place, and it was hard to read.

After a quick web search, I found EPPlus, which did exactly what I needed. I wanted to both write the spreadsheet to a file, and to build it in memory and attach it to an email which my software sends in the background without opening up an email client. The first I figured would be easy, but the second required writing to a stream, and EPPlus was already set up to allow for both files and in-memory streams. A few hours of data layout on multiple pages, and voila! I have formatting, sorting, column sizing, and as many pages as I need. Alas, I don't know how to build a pivot table worth beans, but EPPlus does that, too, according to the docs.

Their sample code project was really helpful to look up things like formatting and sizing of cells. The whole update to my code got me thinking of how you can do really cool stuff by intersecting multiple areas of expertise. Mix computer based testing with Excel and email, and you can end up with something pretty slick. It's the sort of programmer candy contract coders thrive on.

C# Version Numer Tip

Have you ever tried to store data in the application properties in C#? It has some really slick abilities to store settings for you. I use it for window sizes and things like that. All you do is add data to your settings (usually found in Properties/Settings.settings in your project), then reference them. You start off by getting your application set up to use settings with this "using" statement:

using System.Configuration;

You read and write them like this:

internalValue = Properties.Settings.Default.MyNamedSetting;
// modify your internal value.

Properties.Settings.Default.MyNamedSetting = internalValue;

The tricky part is that every time you update your application version number, these settings are left behind and it creates a new set for you. How do you get around such a problem? By using a couple of the more obscure features of Properties.Settings.Default.

First, you need a way to detect when it's a new version. You can do that by creating a boolean settings entry named something like FirstRun with a default value of true. You can tell if it's your very first time to run the application at a particular version number because it will have the default value of true. Then you can set the value of FirstRun to false. By using the special built-in Upgrade() function, and saving the results, you can import your previous data just like this:

if(Properties.Settings.Default.FirstRun)
{
    Properties.Settings.Default.Upgrade();
    Properties.Settings.Default.FirstRun = false;
    Properties.Settings.Default.Save();
}

There. Now you have a system that automatically detects version bumps, and saves all your special settings from one version to the next.