Which consumes less space, UInt64 or a string in C#

Question

What will be the best idea in the context of C#,

1. In C# i am using a dictionary. I want it to use less memory space. what will be better?

   A dictionary where the key type is Uint64 or where the key type is a string? in both cases the value is a custom class which is same for each dictionary.

   I have declared the dictionary as following,

   private static readonly Dictionary<string, List<Node>> HashTable =
       new Dictionary<string, List<Node>>();
   

   class node is defined as below,

   public class Node
   {
       public UInt64 CurrentIndex { get; set; }
       public string NextHashedString { get; set; }
       public int NextHashPos { get; set; }
   }
   

   The key of the string is actually is a hashvalue from a string computed as follows, The length of string may be 1 to 20 characters.

   static UInt64 CalculateHash(string read, bool lowTolerance)
   {
       UInt64 hashedValue = 0;
       int i = 0;
       while (i < read.Length)
       {
           hashedValue += read.ElementAt(i) * (UInt64)Math.Pow(31, i);
           if (lowTolerance) i += 2;
           else i++;
       }
       return hashedValue;
   }
   

   Now, I want to store this hash value as a key to the dictionary. What will be the best idea. I use as Uint64 or I convert it to string and use string as a dictionary key. My primary goal is the dictionary uses minimum space and search time for a key is faster.

2. I have a file with 3571079 characters. Can I read the whole file into a string or I need advanced data structures?

Answer 1

Using a UInt64 instead of a string (or any other reference type) as a key for a dictionary will practically consume less memory. Using a reference type like string requires the dictionary to store the reference to the key in it's internal data structure which will cause the referenced object (the string) to be kept in memory as well, including the per-object overhead etc. When the key is a UInt64, the (current implementation of the) dictionary stores the value of the key instead of a reference to the key (as part of the normal way how generics work) without any separate key objects.

There's only one situation I can think of where a UInt64 key could cause higher memory usage than a string: if the process is 32bit (x86) references are 32 bit. If the dictionary is large, but almost empty, there will be many empty Dictionary<K,V>.Entry instances. For UInt64 keys the key part of those instances will be 64bit (even if no explicit value is assigned) while for string keys it's only 32 bit. So the total amount of allocated memory will be more for the dictionary with UInt64 keys. But this is a very theoretical situation.

So, if you can use UInt64 keys instead of strings without sacrificing other qualities of your software design, there's nothing wrong with using them. But don't start to optimize before it's really necessary. To say it with the words of Donald Knuth: "premature optimization is the root of all evil"

Update: as you've updated your post to show how your UInt64 values are calculated:

1. If you would simply derive the string key by calling ToString on the UInt64 value you should go for the UInt64 version in the first place. It'll be more efficient by all means.

2. Using a hash as a key can be somewhat tricky. You need to make sure that the hashes don't collide. Your hash function doesn't look particularly good on the first sight, but this of course depends on your use case. But this is outside of the scope of this question I suppose.