I have this class:
public class SomeClass
{
public string Str1 { get; set; }
public string Str2 { get; set; }
public string Str3 { get; set; }
public string Str4 { get; set; }
}
and I would like to create a hashkey, which is persisted in a database as varbinary(20), to determine uniqueness of the class (case insensitive). I guess the usual GetHashCode method could not be used in this case. What would be best practice in this scenario?
Simple example:
public class SomeClass
{
public string Str1 { get; set; }
public string Str2 { get; set; }
public string Str3 { get; set; }
public string Str4 { get; set; }
public byte[] SHA256()
{
using (var sha256 = new SHA256Managed())
{
var strings = new[] { Str1, Str2, Str3, Str4 };
for (int i = 0; i < strings.Length; i++)
{
string str = strings[i];
if (str != null)
{
// Commented lines are for using ToUpperInvariant()
//str = str.ToUpperInvariant()
byte[] length2 = BitConverter.GetBytes(str.Length);
sha256.TransformBlock(length2, 0, length2.Length, length2, 0);
// byte[] sortKeyBytes = Encoding.UTF8.GetBytes(str);
byte[] sortKeyBytes = CultureInfo.InvariantCulture.CompareInfo.GetSortKey(str, CompareOptions.IgnoreCase).KeyData;
sha256.TransformBlock(sortKeyBytes, 0, sortKeyBytes.Length, sortKeyBytes, 0);
}
else
{
byte[] length2 = BitConverter.GetBytes(-1);
sha256.TransformBlock(length2, 0, length2.Length, length2, 0);
}
}
sha256.TransformFinalBlock(new byte[0], 0, 0);
byte[] hash = sha256.Hash;
return hash;
}
}
}
I'm using SHA256 and the solution is based on the solution suggested by @usr in https://stackoverflow.com/a/10452967/613130 . The generated hash code is 32 bytes long, but you can truncate it to 20 (clearly you'll reduce its uniqueness).
I prepend the length of the various strings to the strings. In this way { "ABCD", "", "", "" } will produce a different hash than { "A", "B", "C", "D" }.
If you prefer you can use good old ToUpperInvariant() and hash based on it (there are some commented lines in the code... You uncomment them, remove the byte[] sortKeyBytes = CultureInfo.InvariantCulture and live happy :-) ).
I have to tell the truth, I'm not sure of the "stability" of GetSortKey... Will GetSortKey return the same weights in 5 years, in .NET 10.0 with Unicode 11.0? Who knows? I surely don't!
MSDN suggests that they could change:
If an application serializes a SortKey object, the application must regenerate all the sort keys when there is a new version of the .NET Framework.
So in the end I suggest the alternative solution based on .ToUpperInvariant() (to be clear, if my boss asked me to do it, I would tell him: use .ToUpperInvariant()). Note that even with .ToUpperInvariant() there could be small changes in the future. New upper case characters could be introduced for existing lower case characters. See http://unicode.org/faq/casemap_charprop.html "Can a case pair be added if one of the pair is already encoded?"
A varbinary(20) is 160 bits so you are looking for a 160 bit hash algorithm. The SHA-1 algorithm produces a 160 bit hash value.
It seems that the purpose of your question is to create a hash value that is expected to be unique for a given instance of SomeClass so you should favor fast hash algorithms over cryptographic hash algorithms. SHA-1 is a cryptographic algorithm but it is pretty fast and there is an implementation in the .NET Framework. Also, there exists attacks on the SHA-1 algorithm so you should not use it for cryptographic purposes but instead chose algorithms like SHA-256 (that are slower).
All in all I believe that SHA-1 is a good fit for your problem. It is simple to use the algorithm. 1) Concatenate the strings, 2) convert them to upper case, 3) convert them to bytes using a suitable encoding (I use UTF-8) and 4) compute the hash:
Byte[] GetHash(SomeClass someClass) {
if (someClass == null)
throw new ArgumentNullException("someClass");
var byteBuffers = GetStrings(someClass).Select(
s => String.IsNullOrEmpty(s)
? new Byte[0] : Encoding.UTF8.GetBytes(s.ToUpperInvariant())
);
var bytes = byteBuffers
.Aggregate(new List<Byte>(), (l, b) => { l.AddRange(b); return l; })
.ToArray();
using (var sha1 = new SHA1Managed())
return sha1.ComputeHash(bytes);
}
IEnumerable<String> GetStrings(SomeClass someClass) {
yield return someClass.Str1;
yield return someClass.Str2;
yield return someClass.Str3;
yield return someClass.Str4;
}
Note that any hash algorithm (also cryptographic algorithms) can and will produce collisions.
Xanatos has a very good point:
I prepend the length of the various strings to the strings. In this way
{ "ABCD", "", "", "" }will produce a different hash than{ "A", "B", "C", "D" }.
Here is an alternative solution that solves the same problem in a slightly different way where each string length modulo 256 is included in the hash:
Byte[] GetHash(SomeClass someClass) {
if (someClass == null)
throw new ArgumentNullException("someClass");
var byteBuffers = GetBuffers(GetStrings(someClass));
var bytes = byteBuffers
.Aggregate(new List<Byte>(), (l, b) => { l.AddRange(b); return l; })
.ToArray();
using (var sha1 = new SHA1Managed())
return sha1.ComputeHash(bytes);
}
IEnumerable<String> GetStrings(SomeClass someClass) {
yield return someClass.Str1?.ToUpperInvariant();
yield return someClass.Str2?.ToUpperInvariant();
yield return someClass.Str3?.ToUpperInvariant();
yield return someClass.Str4?.ToUpperInvariant();
}
IEnumerable<Byte[]> GetBuffers(IEnumerable<String> strings) {
foreach (var @string in strings) {
if (!String.IsNullOrEmpty(@string)) {
yield return new[] { (Byte) (@string.Length%256) };
yield return Encoding.UTF8.GetBytes(@string);
}
else
yield return new Byte[1];
}
}
