Question

Lets say I have an object that has stringProp1, stringProp2. I wish to store each combination of stringProp1, stringProp2 in a Dictionary. Initially I was storing the key as key = stringProp1+stringProp2 but this can actually cause a bug depending on the 2 values. Is the best solution for this problem to create a custom dictionary class or is there a better way using built-in .NET classes?

Answer 1

It does not matter what data structure you use as the key as long as the key holds the necessary information for a comparer to properly compare/hash.

You can even use your objects as keys in the dictionary and compare on any field you like with an appropriate EqualityComparer implementation. This one compares on two string properties using ordinal comparison:

class MyObject
{
    public string StringProp1 { get; set; }
    public string StringProp2 { get; set; }
    public MyObject(string prop1, string prop2)
    {
        StringProp1 = prop1;
        StringProp2 = prop2;
    }
}

class MyObjectComparerS1S2 : EqualityComparer<MyObject>
{
    //Change this if you need e.g. case insensitivity or 
    //culture-specific comparisons
    static StringComparer comparer = StringComparer.Ordinal;

    public override bool Equals(MyObject x, MyObject y)
    {
        return 
            comparer.Equals(x.StringProp1, y.StringProp1) &&
            comparer.Equals(x.StringProp2, y.StringProp2);
    }

    public override int GetHashCode(MyObject obj)
    {
        //Uncomment this if running in a checked context
        //Copycat of Jon Skeet's string hash combining
        //unchecked
        //{
            return 
                (527 + comparer.GetHashCode(obj.StringProp1)) * 31 +
                comparer.GetHashCode(obj.StringProp2);
        //}
    }

    public static readonly MyObjectComparerS1S2 Instance = 
        new MyObjectComparerS1S2();

}

static void Main(string[] args)
{
    Dictionary<MyObject, MyObject> dict = 
        new Dictionary<MyObject, MyObject>(MyObjectComparerS1S2.Instance);
    MyObject obj = new MyObject("apple", "plum");
    dict.Add(obj, obj);
    MyObject search = new MyObject("apple", "plum");
    MyObject result = dict[search];
    Console.WriteLine("{0}:{1}", result.StringProp1, result.StringProp2);
}

You can search for an object by creating a dummy one, filling in the string keys and using the dummy as the key for the lookup.
If you do not like this idea, or it is not feasible, just do as @Vlad said and extract the keys in a struct or class. In this case, modify the comparer to derive from EqualityComparer<MyKeyStructOrClass>.

Note that I’ve used Jon Skeet’s method for combining string hashes. It might be better than the XOR method found on MSDN. If you feel that it is steel inadequate, feel free to treat the strings with another hash implementation – Hsieh, Murmur, Bob Jenkin’s, or whatever you believe in. Here is a nice page about hash functions that actually has some C# code as well.