Custom Hashtable C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
 
namespace DataTypeSpeedTests
{
    public class MKD<K, V>
    {
        //internal readonly List<Dictionary<K, V>> DictionaryList = new List<Dictionary<K, V>>();
        //internal readonly List<Dictionary<K, V>> DictionaryList = new List<Dictionary<K, V>>();
        //internal readonly List<Dictionary<K, Dictionary<K, V>>> ListOfDictionaries = new List<Dictionary<K, Dictionary<K, V>>>();
        //internal readonly Dictionary<int, string> TopLevelInt2String = new Dictionary<int, string>();
        //internal readonly List<K> 
        //internal int TopLevelCount = 0;
 
        //internal readonly Dictionary<string, Dictionary<K, List<V>>> MultiKeyDictionary = new Dictionary<string, Dictionary<K, List<V>>>();
 
        internal readonly List<Dictionary<K, List<V>>> MultiKeyDictionary = new List<Dictionary<K, List<V>>>();
        public readonly List<string> TopLevelKeyNameList = new List<string>();
        public readonly Dictionary<string, int> TopLevelKeyNoList = new Dictionary<string, int>();
        
 
        //internal readonly PropertyInfo[] ValueProperties = typeof(V).GetProperties();
        //internal readonly List<K> TopLevelKeyObjectList = new List<K>();
 
 
        readonly object lockObject = new object();
 
        /// <summary>
        /// Gets or sets the Value.
        /// </summary>
        /// <value>The Value.</value>
        public V Value
        {
            get;
            set;
        }
 
        /// <summary>
        /// Gets or sets the Key.
        /// </summary>
        /// <value>The Key.</value>
        public K Key
        {
            get;
            set;
        }
 
        /// <summary>
        /// Gets the value from Keys and List Index
        /// </summary>
        /// <remarks></remarks>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="ListPosition">Position In The Value List.</param>
        public V this[string TopLevelDicName, K BottomLevelKey, int ListPosition]
        {
            get
            {
                V value;
                if (TryGetValue(TopLevelDicName, BottomLevelKey, ListPosition, out value))
                    return value;
                else
                    throw new KeyNotFoundException("Not found: " + TopLevelDicName.ToString() + " " + BottomLevelKey.ToString() + " " + ListPosition.ToString());
            }
        }
 
        /// <summary>
        /// Gets the value from Keys and List Index
        /// </summary>
        /// <remarks></remarks>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="ListPosition">Position In The Value List.</param>
        public V this[int TopLevelDicNo, K BottomLevelKey, int ListPosition]
        {
            get
            {
                V value;
                if (TryGetValue(TopLevelDicNo, BottomLevelKey, ListPosition, out value))
                    return value;
                else
                    throw new KeyNotFoundException("Not found: " + TopLevelDicNo.ToString() + " " + BottomLevelKey.ToString() + " " + ListPosition.ToString());
            }
        }
 
        /// <summary>
        /// Gets the list of values from Keys and List Index
        /// </summary>
        /// <remarks></remarks>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        /// <param name="key">Bottom Level Key</param>
        public List<V> this[string TopLevelDicName, K BottomLevelKey]
        {
            get
            {
                List<V> ListValue;
                if (TryGetValueList(TopLevelDicName, BottomLevelKey, out ListValue))
                    return ListValue;
                else
                    throw new KeyNotFoundException("Not found: " + TopLevelDicName.ToString() + " " + BottomLevelKey.ToString());
            }
        }
 
        /// <summary>
        /// Gets the list of values from Keys and List Index
        /// </summary>
        /// <remarks></remarks>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        /// <param name="key">Bottom Level Key</param>
        public List<V> this[int TopLevelDicNo, K BottomLevelKey]
        {
            get
            {
                List<V> ListValue;
                if (TryGetValueList(TopLevelDicNo, BottomLevelKey, out ListValue))
                    return ListValue;
                else
                    throw new KeyNotFoundException("Not found: " + TopLevelDicNo.ToString() + " " + BottomLevelKey.ToString());
            }
        }
 
        /// <summary>
        /// MKD Class constructor
        /// </summary>
        /// <remarks></remarks>
        /// <param name="Keys">The list of keys to be used; </param>
        /// <param name="newClassValue">An instance of the item - does not need to contain a value; just important to establish the type</param>
        /// <typeparam name="V">
        /// The type of the object that should be stored
        /// </typeparam>
        /// <typeparam name="K">
        /// All the keys must be of the same type (K).
        /// </typeparam>
        public MKD(List<K> Keys, V newClassValue) //string Property2Dictionary
        {
            int i = 0;
            foreach (K key in Keys)
            {
                if (newClassValue.GetType().GetProperty(key.ToString()) != null)
                {
                    try
                    {
                        MultiKeyDictionary.Add(new Dictionary<K, List<V>>());
                        //TopLevelKeyObjectList.Add(key);
                        TopLevelKeyNameList.Add(key.ToString());
                        TopLevelKeyNoList.Add(key.ToString(),i);
                        i++;
                        //TopLevelInt2String.Add(MultiKeyDictionary.Count, key.ToString());
                    }
                    catch (Exception e)
                    {
                        throw e;
                    }
                }
                else
                    throw new System.Exception(key.ToString() + " is not in the " + newClassValue.ToString() + " class; correct the list which is used in the constructor.");
            }
        }
 
        /// <summary>
        /// Get Top Level Dictionary Name By It's "Number"
        /// </summary>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        public string GetTopLevelDictionaryName(int TopLevelDicNo)
        {
            return TopLevelKeyNameList[TopLevelDicNo];
        }
 
        /// <summary>
        /// Verify That Top Level Dictionary Exists By It's Name
        /// </summary>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        public bool ContainsTopLevelKey(string TopLevelDicName)
        {
            return TopLevelKeyNameList.Contains(TopLevelDicName);
                //MultiKeyDictionary.ContainsKey(TopLevelDicName);
        }
 
        /// <summary>
        /// Verify That Top Level Dictionary Exists By It's Number
        /// </summary>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        public bool ContainsTopLevelKey(uint TopLevelDicNo)
        {
            return (TopLevelDicNo <= TopLevelKeyNameList.Count);
                //MultiKeyDictionary.ContainsKey(TopLevelKeyNameList[TopLevelDicNo]);
        }
 
        /// <summary>
        /// Verify That Bottom Level Dictionary Exists
        /// </summary>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        /// <param name="key">Bottom Level Key</param>
        public bool ContainsBottomLevelKey(string TopLevelDicName, K key)
        {
            lock (lockObject)
            {
                if (ContainsTopLevelKey(TopLevelDicName)) //MultiKeyDictionary.ContainsKey(TopLevelDicName)
                {
                    if (MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]].ContainsKey(key))
                    {
                        //return true; -- return at the end to unlock the object
                    }
                    else
                        return false;
                }
                else
                    return false;
            }
            return true;
        }
 
        /// <summary>
        /// Verify That Bottom Level Dictionary Exists
        /// </summary>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        /// <param name="key">Bottom Level Key</param>
        public bool ContainsBottomLevelKey(int TopLevelDicNo, K key)
        {
            return ContainsBottomLevelKey(TopLevelKeyNameList[TopLevelDicNo], key);
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value
        /// </summary>
        /// <remarks>
        /// It's a bit more efficient than other override alternatives.
        /// </remarks>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="value">The Value (object).</param>
        public bool ContainsValue(string TopLevelDicName, K key, V value)
        {
            lock (lockObject)
            {
                if (ContainsTopLevelKey(TopLevelDicName))
                {
                    if (MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]].ContainsKey(key))
                    {
                        if (MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]][key].Contains(value))
                        {
                            //return true; -- return at the end to unlock the object
                        }
                        else
                            return false;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            return true;
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value
        /// </summary>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="value">The Value (object).</param>
        public bool ContainsValue(int TopLevelDicNo, K key, V value)
        {
            return ContainsValue(TopLevelKeyNameList[TopLevelDicNo], key, value);
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value
        /// </summary>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        /// <param name="value">The Value (object).</param>
        public bool ContainsValue(string TopLevelDicName, V value)
        {
            lock (lockObject)
            {
                if (ContainsTopLevelKey(TopLevelDicName))
                {
                    foreach (KeyValuePair<K, List<V>> kvp in MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]])
                    {
                        if (kvp.Value.Contains(value))
                            //return true; -- break instead and unlock the object...
                            break;
                    }
                    return false;
                }
                else
                    return false;
            }
            return true; // unreachable code is a fib, because of the break in the foreach loop.
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value
        /// </summary>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        /// <param name="value">The Value (object).</param>
        public bool ContainsValue(int TopLevelDicNo, V value)
        {
            return ContainsValue(TopLevelKeyNameList[TopLevelDicNo], value);
        }
 
        
 
        /// <summary>
        /// Verify That Dictionary Contains Value; Get First Value - And The List Of Values.
        /// </summary>
        /// <remarks>
        /// Hopefully the overhead of doing this would not be too high...
        /// </remarks>
        /// <returns>The Count Of Values In The List</returns>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="value">(output) - The Value (object).</param>
        /// <param name="ListVal">(output) - The List Of Values (object list).</param>
        public uint TryGetValueAndValueList(string TopLevelDicName, K key, out V value, out List<V> ListVal)
        {
            lock (lockObject)
            {
                if (ContainsTopLevelKey(TopLevelDicName))//.TryGetValue(TopLevelDicName, out Ds)
                {
                    if (MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]].ContainsKey(key))
                    {
                        if (MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]].TryGetValue(key, out ListVal))
                        {
                            value = ListVal[0];
                            return (uint)ListVal.Count;
                        }
                        else
                        {
                            ListVal = default(List<V>);
                            value = default(V);
                            return 0;
                        }
                    }
                    else
                    {
                        ListVal = default(List<V>);
                        value = default(V);
                        return 0;
                    }
                }
                else
                {
                    ListVal = default(List<V>);
                    value = default(V);
                    return 0;
                }
            }
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value; Get First Value - And The List Of Values.
        /// </summary>
        /// <remarks>
        /// Hopefully the overhead of doing this would not be too high...
        /// </remarks>
        /// <returns>The Count Of Values In The List</returns>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="value">(output) - The Value (object).</param>
        /// <param name="ListVal">(output) - The List Of Values (object list).</param>
        public uint TryGetValueAndValueList(int TopLevelDicNo, K key, out V value, out List<V> ListVal)
        {
            lock (lockObject)
            {
                if (TopLevelDicNo >= 0 && TopLevelDicNo <= TopLevelKeyNameList.Count)
                {
                    if (MultiKeyDictionary[TopLevelDicNo].ContainsKey(key))
                    {
                        if (MultiKeyDictionary[TopLevelDicNo].TryGetValue(key, out ListVal))
                        {
                            value = ListVal[0];
                            return (uint)ListVal.Count;
                        }
                        else
                        {
                            ListVal = default(List<V>);
                            value = default(V);
                            return 0;
                        }
                    }
                    else
                    {
                        ListVal = default(List<V>);
                        value = default(V);
                        return 0;
                    }
                }
                else
                {
                    ListVal = default(List<V>);
                    value = default(V);
                    return 0;
                }
            }
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value and Get Value.
        /// </summary>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="ListPosition">Position In The Value List.</param>
        /// <param name="value">(output) - The Value (object).</param>
        public bool TryGetValue(string TopLevelDicName, K key, int ListPosition, out V value)
        {
            lock (lockObject)
            {
                if (ListPosition >= 0 && ContainsTopLevelKey(TopLevelDicName))//.TryGetValue(TopLevelDicName, out Ds)
                {
                    if (MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]].ContainsKey(key))
                    {
                        if (ListPosition <= MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]][key].Count) // .TryGetValue(key, out ListVal))
                        {
                            value = MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]][key][ListPosition];
                            return true; // return true at the end to unlock object???
                        }
                        else
                        {
                            value = default(V);
                            return false;
                        }
                    }
                    else
                    {
                        value = default(V);
                        return false;
                    }
                }
                else
                {
                    value = default(V);
                    return false;
                }
            }
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value and Get The Value.
        /// </summary>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="ListPosition">Position In The Value List.</param>
        /// <param name="value">(output) - The Value (object).</param>
        public bool TryGetValue(int TopLevelDicNo, K key, int ListPosition, out V value)
        {
            lock (lockObject)
            {
                if (ListPosition >= 0 && ListPosition <= TopLevelKeyNameList.Count)//.TryGetValue(TopLevelDicName, out Ds)
                {
                    if (MultiKeyDictionary[TopLevelDicNo].ContainsKey(key))
                    {
                        if (ListPosition <= MultiKeyDictionary[TopLevelDicNo][key].Count) // .TryGetValue(key, out ListVal))
                        {
                            value = MultiKeyDictionary[TopLevelDicNo][key][ListPosition];
                            return true; // return true at the end to unlock object???
                        }
                        else
                        {
                            value = default(V);
                            return false;
                        }
                    }
                    else
                    {
                        value = default(V);
                        return false;
                    }
                }
                else
                {
                    value = default(V);
                    return false;
                }
            }
            //return TryGetValue(TopLevelKeyNameList[TopLevelDicNo], key, ListPosition, out  value);
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value and Get First Value.
        /// </summary>
        /// <remarks>
        /// Major Weakness - there may be more elements in the list...
        /// </remarks>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="ListPosition">Position In The Value List.</param>
        /// <param name="value">(output) - The Value (object).</param>
        public bool TryGetFirstValue(string TopLevelDicName, K key, out V value)
        {
            return TryGetValue(TopLevelDicName, key, 0, out value);
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value and Get Value List.
        /// </summary>
        /// <param name="TopLevelDicName">Top Level Dictionary's Name</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="ListVal">(output) - The Value List (List Of Value Objects).</param>
        public bool TryGetValueList(string TopLevelDicName, K key, out List<V> ListVal)
        {
            lock (lockObject)
            {
                if (ContainsTopLevelKey(TopLevelDicName))//.TryGetValue(TopLevelDicName, out Ds)
                {
                    if (MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]].ContainsKey(key))
                    {
                        if (MultiKeyDictionary[TopLevelKeyNoList[TopLevelDicName]].TryGetValue(key, out ListVal))
                        {
                            return true; // return true at the end to unlock object???
                        }
                        else
                        {
                            ListVal = default(List<V>);
                            return false;
                        }
                    }
                    else
                    {
                        ListVal = default(List<V>);
                        return false;
                    }
                }
                else
                {
                    ListVal = default(List<V>);
                    return false;
                }
            }
        }
 
        /// <summary>
        /// Verify That Dictionary Contains Value and Get Value List.
        /// </summary>
        /// <param name="TopLevelDicNo">Top Level Dictionary's Number</param>
        /// <param name="key">Bottom Level Key</param>
        /// <param name="ListVal">(output) - The Value List (List Of Value Objects).</param>
        public bool TryGetValueList(int TopLevelDicNo, K key, out List<V> ListVal)
        {
            lock (lockObject)
            {
                if (TopLevelDicNo >= 0 && TopLevelDicNo <= TopLevelKeyNameList.Count)
                {
                    if (MultiKeyDictionary[TopLevelDicNo].ContainsKey(key))
                    {
                        if (MultiKeyDictionary[TopLevelDicNo].TryGetValue(key, out ListVal))
                        {
                            return true; // return true at the end to unlock object???
                        }
                        else
                        {
                            ListVal = default(List<V>);
                            return false;
                        }
                    }
                    else
                    {
                        ListVal = default(List<V>);
                        return false;
                    }
                }
                else
                {
                    ListVal = default(List<V>);
                    return false;
                }
            }
        }
 
        /// <summary>
        /// Add Value To All Dictionaries.
        /// </summary>
        /// <param name="value">The Value (Of Type V) To Be Added.</param>
        public void AddItem(V value)
        {
            lock (lockObject)
            {
                for (int i = 0; i < TopLevelKeyNameList.Count; i++)
                {
                    List<V> ListValues;
                    K KeyFromValue = default(K);
                    object o = value.GetType().GetProperty(TopLevelKeyNameList[i]).GetValue(value, null);
                    if (o != null)
                    {
                        KeyFromValue = (K)o;
                        if (MultiKeyDictionary[i].TryGetValue(KeyFromValue, out ListValues)) //ContainsKey(KeyFromValue))
                        {
                            ListValues.Add(value);
                        }
                        else
                        {
                            ListValues = new List<V>();
                            ListValues.Add(value);
                            MultiKeyDictionary[i].Add(KeyFromValue, ListValues);
                        }
                    }
                }
            }
        }
 
 
 
        /// <summary>
        /// Add Value To All Dictionaries.
        /// </summary>
        /// <param name="value">The Value (Of Type V) To Be Added.</param>
        public void AddItemNew(V value)
        {
            for (int i = 0; i < TopLevelKeyNameList.Count; i++)
            {
                try
                {
                    K KeyFromValue = (K)value.GetType().GetProperty(TopLevelKeyNameList[i]).GetValue(value, null);
                    try
                    {
                        MultiKeyDictionary[i].Add(KeyFromValue, new List<V>(new V[]{value}));
                    }
                    catch
                    {
                        // the key already exists...
                        try
                        {
                            MultiKeyDictionary[i][KeyFromValue].Add(value);
                        }
                        catch
                        {
                            throw;
                        }
                    }
                }
                catch
                {
                    // no object in value, ignore...
                }
            }
        }
 
 
 
 
        /// <summary>
        /// Remove Value From All Dictionaries.
        /// </summary>
        /// <param name="value">The Value (Of Type V) To Be Removed.</param>
        public void RemoveItem(V value)
        {
            lock (lockObject)
            {
                for (int i = 0; i < TopLevelKeyNameList.Count; i++)
                {
                    List<V> ListValues = default(List<V>);
                    K KeyFromValue = default(K);
                    object o = value.GetType().GetProperty(TopLevelKeyNameList[i]).GetValue(value, null);
                    if (o != null)
                    {
                        KeyFromValue = (K)o;
                        if (MultiKeyDictionary[i].TryGetValue(KeyFromValue, out ListValues)) //ContainsKey(KeyFromValue))
                        {
                            int cnt_before_removing = ListValues.Count;
                            ListValues.Remove(value); // todo - need to check that removing the value in THIS list does not remove it in OTHER lists.
                            // if this was the only value in this dictionary, remove key from dictionary too.
                            if (cnt_before_removing == 1)
                                MultiKeyDictionary[i].Remove(KeyFromValue);
                        }
                        else
                        {
                            //do nothing...
                        }
                    }
                }
                value = default(V);
            }
        }
 
 
        /// <summary>
        /// Removes All Keys And Values From MKD Dictionary.
        /// </summary>
        public void Clear()
        {
            lock (lockObject) 
                MultiKeyDictionary.Clear();
        }
 
 
 
    }
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602:
603:
604:
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645:
646:
647:
648:
649:
650:
651:
652:
653:
654:
655:
656:
657:
658:
659:
660:
661:
662:
663:
664:
665:
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691:
692:
693:
694:
695:

    public class MKD2<T, V>
    {
        private readonly Dictionary<T, List<V>> dictionary;
 
        public MKD2() { dictionary = new Dictionary<T, List<V>>(); }
 
        public void Add(T key, V item) 
        {
           List<V> entry;
           if(!dictionary.TryGetValue(key, out entry)) 
           { 
               entry = new List<V>();
               dictionary.Add(key, entry);
           }
           entry.Add(item);
        }
 
        public void Remove(T key) 
        {
           dictionary.Remove(key);
        }
 
        public void Clear() 
        {
           dictionary.Clear();
        }
 
        public void Remove(T key, V value) 
        {
           List<V> entry;
           if(dictionary.TryGetValue(key, out entry)) { 
                entry.Remove(value);
           }
        }
 
        public IEnumerable<V> Get(T key) 
        {
           List<V> entry;
           if(!dictionary.TryGetValue(key, out entry)) throw new Exception("Bad key");
           return entry; //might want to use .ToArray() here in multi threaded code
        }
    }

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

    public class MKD2<K, V>
    {
        private readonly Dictionary<K, List<V>>[] dictionary;
 
        public byte DymentionCount
        {
            get;
            set;
        }
 
        public MKD2() 
        {
            DymentionCount = 1;
            dictionary = new Dictionary<K, List<V>>[1];
            dictionary[0] = new Dictionary<K, List<V>>(); 
        }
 
        public MKD2(byte dymentionCount)
        {
            if (dymentionCount == 0) dymentionCount = 1;
            DymentionCount = dymentionCount;
            dictionary = new Dictionary<K, List<V>>[DymentionCount];
            for (int i = 0; i < DymentionCount; i++)
            {
                dictionary[i] = new Dictionary<K, List<V>>();
            }
        }
 
        public int GetDimentionLength(byte dymention)
        {
            if (dictionary[dymention] == null)
                return 0;
            else
                return dictionary[dymention].Count;
        }
 
        public void Add(K key, V item)
        {
            List<V> entry;
            if (!dictionary[0].TryGetValue(key, out entry))
            {
                entry = new List<V>();
                dictionary[0].Add(key, entry);
            }
            entry.Add(item);
        }
 
        public void Add(K key, V item, byte dymention)
        {
            List<V> entry;
            if (!dictionary[dymention].TryGetValue(key, out entry))
            {
                entry = new List<V>();
                dictionary[dymention].Add(key, entry);
            }
            entry.Add(item);
        }
 
        public void Remove(K key)
        {
            dictionary[0].Remove(key);
        }
 
        public void Remove(K key, byte dymention)
        {
            dictionary[dymention].Remove(key);
        }
 
        public void Clear()
        {
            dictionary[0].Clear();
        }
 
        public void Clear(byte dymention)
        {
            dictionary[dymention].Clear();
        }
 
        public void Remove(K key, V value)
        {
            List<V> entry;
            if (dictionary[0].TryGetValue(key, out entry))
            {
                entry.Remove(value);
            }
        }
 
        public void Remove(K key, V value, byte dymention)
        {
            List<V> entry;
            if (dictionary[dymention].TryGetValue(key, out entry))
            {
                entry.Remove(value);
            }
        }
 
        public List<V> Get(K key) //IEnumerable<V>
        {
            List<V> entry;
            if (!dictionary[0].TryGetValue(key, out entry)) throw new Exception("Bad key");
            return entry; //might want to use .ToArray() here in multi threaded code
        }
 
        public List<V> Get(K key, byte dymention) //IEnumerable<V>
        {
            List<V> entry;
            if (!dictionary[dymention].TryGetValue(key, out entry)) throw new Exception("Bad key");
            return entry; //might want to use .ToArray() here in multi threaded code
        }
 
        public List<V> GetFlatDymentionValueList(byte dymention)
        {
            List<V> full_list = new List<V>();
            foreach (KeyValuePair<K,List<V>> kvp in dictionary[dymention])
	        {
                full_list.AddRange(kvp.Value);
	        }
            return full_list;
        }
 
        public List<K> GetFlatDimentionKeyList(byte dymention)
        {
            List<K> full_list = new List<K>();
            foreach (KeyValuePair<K, List<V>> kvp in dictionary[dymention])
            {
                full_list.Add(kvp.Key);
            }
            return full_list;
        }
    }

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:

            foreach (KeyValuePair<long, List<ActivityDetails_HashedLib>> item in cht.GetKVPList(0))
            {
                foreach(ActivityDetails_HashedLib hl in item.Value)
                {
                    cht.Remove(item.Key, hl, 0);
                }
                cht.Remove(item.Key);
            }

                                              

1:
2:
3:
4:
5:
6:
7:
8: