Is there a better, more efficient way than Dictionary(Of Tuple(), MyClass)?

Question

Suppose I have data coming from different sources that tells me information about a large group of stores that has the following (just an example):

Necessary to define what store we're dealing with:

• Store_Name (String)
• Location (String)

Store characteristics:

• Square_Feet (Double)
• No_Employees (Double)
• Years_Open (Double)
• ... (Whatever else)

And the structure of the program I'm working with is such that we will always get the first 2 (defining) characteristics and one or more of the store-specific characteristics. My goal is to conglomerate all the characteristics for each of the specific stores together.

To do this, I have created the following class:

Public Class StoreChars
    Public Property Square_Feet as Double = 0
    Public Property No_Employees as Double = 0
    Public Property Years_Open as Double = 0
    ...
End Class

And then, in my program, I have created the following:

Dim StoreData As New Dictionary(Of Tuple(Of String, String), StoreChars)

The key being the Store_Name and Location as the defining tuple.

So, now, in my code, supposing I just got some data together with the defining characteristics for a set of stores (might be some, might be all... we don't know if we've seen these before or not even), my loop to put in that data looks as follows:

For Each PieceOfInfo in ReturnedData
   Dim TupleKey As New Tuple(Of String, String)(PieceOfInfo.Store_Name,
                                                PieceOfInfo.Location)

   If Not StoreData.ContainsKey(TupleKey) Then
        StoreData.Add(TupleKey, New StoreChars With 
                                {
                                 .Square_Feet = PieceOfInfo.Square_Feet
                                     ... (whatever else we got) ...
                                })
   Else
        StoreData(TupleKey).Square_Feet = PieceOfInfo.Square_Feet
                     ... (whatever else we got) ...
   End If
Next

But this seems to be very slow and I'm wondering if it isn't overly-processor-intensive to create a tuple in each loop, check the existence as a key, etc, but I can't think of a better way to do this.

The other solution I was thinking of was to create a Dictionary(Of String, Dictionary(Of String, StoreChars)). That would eliminate having to create a Tuple with each loop, but it would mean having to check existence of the keys in 2 separate dictionaries.

If there is a better way to do this, I would LOVE to hear what it is because I find myself having to program solutions like this fairly often!

Also, even though I wrote this code in VB, I'm just as comfortable with a C# solution - I'm just currently working in a VB environment.

Answer 1

Turns out I had a String, String KeyedCollection in my archive

using System.Collections.ObjectModel;

namespace KeyCollStringString
{
    class Program
    {
        static void Main(string[] args)
        {
            StringStringO ss1 = new StringStringO("Sall","John");
            StringStringO ss2 = new StringStringO("Sall", "John");
            if (ss1 == ss2) Console.WriteLine("same");
            if (ss1.Equals(ss2)) Console.WriteLine("equals");
            // that are equal but not the same I don't override = so I have both features

            StringStringCollection stringStringCollection = new StringStringCollection();
            // dont't have to repeat the key like Dictionary
            stringStringCollection.Add(new StringStringO("Ringo", "Paul"));
            stringStringCollection.Add(new StringStringO("Mary", "Paul"));
            stringStringCollection.Add(ss1);
            //this would thow a duplicate key error
            //stringStringCollection.Add(ss2);
            //this would thow a duplicate key error
            //stringStringCollection.Add(new StringStringO("Ringo", "Paul"));
            Console.WriteLine("count");
            Console.WriteLine(stringStringCollection.Count.ToString());
            // reference by ordinal postion (note the is not the long key)
            Console.WriteLine("oridinal");
            Console.WriteLine(stringStringCollection[0].GetHashCode().ToString());
            // reference by index
            Console.WriteLine("index");
            Console.WriteLine(stringStringCollection["Mary", "Paul"].GetHashCode().ToString());
            Console.WriteLine("foreach");
            foreach (StringStringO ssO in stringStringCollection)
            {
                Console.WriteLine(string.Format("HashCode {0} String1 {1} String2 {2} ", ssO.GetHashCode(), ssO.String1, ssO.String2));
            }
            Console.WriteLine("sorted by date");
            foreach (StringStringO ssO in stringStringCollection.OrderBy(x => x.String1).ThenBy(x => x.String2))
            {
                Console.WriteLine(string.Format("HashCode {0} String1 {1} String2 {2} ", ssO.GetHashCode(), ssO.String1, ssO.String2));
            }
            Console.ReadLine();
        }
        public class StringStringCollection : KeyedCollection<StringStringS, StringStringO>
        {
            // This parameterless constructor calls the base class constructor 
            // that specifies a dictionary threshold of 0, so that the internal 
            // dictionary is created as soon as an item is added to the  
            // collection. 
            // 
            public StringStringCollection() : base(null, 0) { }

            // This is the only method that absolutely must be overridden, 
            // because without it the KeyedCollection cannot extract the 
            // keys from the items.  
            // 
            protected override StringStringS GetKeyForItem(StringStringO item)
            {
                // In this example, the key is the part number. 
                return item.StringStringS;
            }

            //  indexer 
            public StringStringO this[string String1, string String2]
            {
                get { return this[new StringStringS(String1, String2)]; }
            }
        }

        public struct StringStringS
        {   // required as KeyCollection Key must be a single item
            // but you don't reaaly need to interact with Int32Int32s
            public readonly String String1, String2;
            public StringStringS(string string1, string string2) { this.String1 = string1.Trim(); this.String2 = string2.Trim(); }
        }
        public class StringStringO : Object
        {
            // implement you properties
            public StringStringS StringStringS { get; private set; }
            public String String1 { get { return StringStringS.String1; } }
            public String String2 { get { return StringStringS.String2; } }
            public override bool Equals(Object obj)
            {
                //Check for null and compare run-time types.
                if (obj == null || !(obj is StringStringO)) return false;
                StringStringO item = (StringStringO)obj;
                return (this.String1 == item.String1 && this.String2 == item.String2);
            }
            public override int GetHashCode() 
            {
                int hash = 17;
                // Suitable nullity checks etc, of course :)
                hash = hash * 23 + String1.GetHashCode();
                hash = hash * 31 + String2.GetHashCode();
                return hash;
            }
            public StringStringO(string string1, string string2)
            {
                StringStringS stringStringS = new StringStringS(string1, string2);
                this.StringStringS = stringStringS;
            }
        }
    }
}

Answer 2

If you're stuck with Tuple<T1,T2> as a key, you want to provide an IEqualityComparer<Tuple<T1,T2>> implementation in the constructor of your dictionary.

If you can change the TKey type, you might want to provide a custom class that implements IEquatable<T>.

The problem with the current code is that comparison between keys of type Tuple<string, string> is not efficient.

Answer 3

I take it you are mostly concerned with efficiency in this question (because your code already works).

Instead of using the built-in Tuple (which is a reference type), create a custom struct or struct-based Tuple so that you save on heap allocations. Allocating and GC'ing a new heap object per lookup is indeed expensive.

Be sure to override the equality members.

Answer 4

Another way to do this, is to add the store name and location to the StoreChars class and override the gethashcode function. You can combine the store name and location and create a hashcode to use as the key and the storechars object as the value:

Public Class StoreChars
    Public Property Store_Name As String = ""
    Public Property Location As String = ""
    Public Property Square_Feet As Double = 0
    Public Property No_Employees As Double = 0
    Public Property Years_Open As Double = 0
    Public Overrides Function GetHashCode() As Integer
        Return (Store_Name & Location).GetHashCode
    End Function
End Class

Use it something like this:

Dim StoreData As Dictionary(Of Integer, StoreChars)
For Each PieceOfInfo In ReturnedData
    Dim TempChars As New StoreChars With
        {
            .Store_Name = PieceOfInfo.Store_Name,
            .Location = PieceOfInfo.Location,
            .Square_Feet = PieceOfInfo.Square_Feet,
            .No_Employees = PieceOfInfo.No_Employees,
            .Years_Open = PieceOfInfo.Years_Open
        }
    'If using the hashcode is bothersome you could use 
    'Dim tempkey As String = PieceOfInfo.Store_Name & PieceOfInfo.Location
    Dim tempkey As Integer = TempChars.GetHashCode
    If StoreData.ContainsKey(tempkey) Then
        StoreData(tempkey) = TempChars
    Else
        StoreData.Add(tempkey, TempChars)
    End If
Next

This assumes the properties in pieceofinfo will have have at least a default value and not be nothing.

Creating a new storechars is mainly for readability and maintenance, You could optimize it by creating the hashcode separately from the store name and location strings then adding the other data separately. Since the hashcode is an integer it would probably be more efficient to store it than a tuple.

Here's a revision without the extra object:

For Each PieceOfInfo In ReturnedData
    'If using the hashcode is bothersome you could use 
    'Dim tempkey As String = PieceOfInfo.Store_Name & PieceOfInfo.Location
    Dim tempkey As Integer = (PieceOfInfo.Store_Name & PieceOfInfo.Location).GetHashCode
    If StoreData.ContainsKey(tempkey) Then
        Using StoreData(tempkey)

            .Store_Name = PieceOfInfo.Store_Name
            .Location = PieceOfInfo.Location
            .Square_Feet = PieceOfInfo.Square_eet
            .No_Employees = PieceOfInfo.No_Employees
            .Years_Open = PieceOfInfo.Years_Open
        End Using
    Else
        StoreData.Add(tempkey, New StoreChars With
        {
            .Store_Name = PieceOfInfo.Store_Name,
            .Location = PieceOfInfo.Location,
            .Square_Feet = PieceOfInfo.Square_Feet,
            .No_Employees = PieceOfInfo.No_Employees,
            .Years_Open = PieceOfInfo.Years_Open
        })
    End If
Next

Answer 5

You may like to create a Store class that holds all the properties of the store as

• We are not using the key components individually.
• Also, every class needs to have one purpose.

Then, we can create the dictionary as below

• Dictionary(Of String, Store)
• Key = StoreName & Location

Also, you may simply use Pascal case in variables, using underscore to seperate words is an old convention.

Using concatenated string (StoreName & Location) as the key doesn't seem to be very elegant but it is a simple solution and we don't need to override the GetHashCode method in our class as well.