在我的应用程序中的某个时刻，我遇到了一个类的实例需要三个字符串键（我使用的是C＃3.5，因此我无法使用元组）。通过在线查看，我遇到了我使用的代码：https://stackoverflow.com/a/15804355/5090537
在根据我的需求定制其零碎之后，最后我的自定义类看起来像这样：
public class MultiKeyDictionary<K1, K2, K3, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, V>>
{
public V this[K1 key1, K2 key2, K3 key3]
{
get
{
return ContainsKey(key1) ? this[key1][key2, key3] : default(V);
}
set
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, V>();
this[key1][key2, key3] = value;
}
}
public bool ContainsKey(K1 key1, K2 key2, K3 key3)
{
return base.ContainsKey(key1) && this[key1].ContainsKey(key2, key3);
}
public void Add(K1 key1, K2 key2, K3 key3, V value)
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, V>();
if (!this[key1].ContainsKey(key2, key3))
this[key1][key2] = new Dictionary<K3, V>();
this[key1][key2][key3] = value;
}
}
这对我的需求很有用，但我对这个数据结构有几个问题：
1）因为我实际上是从Dictionary(K1, Dictionary(K2, V))继承的，所以假设为我实现了GetHashCode并且我不需要指定单独的实现是正确的吗？ Equals也一样吗？
2）我还需要创建自己的自定义类正确吗？因为我不能使用字符串数组或字符串列表，因为那时会有一个ReferenceEquals比较，而不是我需要的成员比较（key1等于key1，key2等于key2，key3等于key3）？
好吧，创建一个存储密钥的三键结构是一个很好的计划，但首先让我们看一下source code的KeyValuePair结构。
现在让我们定义我们自己的TripleKey结构：
[Serializable]
public struct TripleKey<TKeyA, TKeyB, TKeyC>
{
public TKeyA KeyA { get; };
public TKeyB KeyB { get; };
public TKeyC KeyC { get; };
public TripleKey(TKeyA keyA, TKeyB keyB, TKeyC keyC)
{
this.KeyA = keyA;
this.KeyB = keyB;
this.KeyC = keyC;
}
// this code is almost the same as it is in Microsoft implementation
public override string ToString()
{
var sBuilder = new StringBuilder();
sBuilder.Append('(');
if (KeyA != null)
{
sBuilder.Append(KeyA.ToString());
}
sBuilder.Append(", ");
if (KeyB != null)
{
sBuilder.Append(KeyB.ToString());
}
sBuilder.Append(", ");
if (KeyC != null)
{
sBuilder.Append(KeyC.ToString());
}
sBuilder.Append(')');
return sBuilder.ToString();
}
}
public static class TripleKey
{
public static TripleKey<TKeyA, TKeyB, TKeyC> Create<TKeyA, TKeyB, TKeyC>(TKeyA keyA, TKeyB keyB, TKeyC keyC)
{
return new TripleKey<TKeyA, TKeyB, TKeyC>(keyA, keyB, keyC);
}
}
public class MultiKeyDictionary<TKeyA, TKeyB, TKeyC, TValue> : Dictionary<TripleKey<TKeyA, TKeyB, TKeyC>, TValue>
{
public TValue this[TKeyA keyA, TKeyB keyB, TKeyC keyC]
{
get
{
var key = TripleKey.Create(keyA, keyB, keyC);
return base.ContainsKey(key) ? base[key] : default(TValue);
}
set
{
var key = TripleKey.Create(keyA, keyB, keyC);
if (!ContainsKey(key))
base.Add(key, value);
this[key] = value;
}
}
public bool ContainsKey(TKeyA keyA, TKeyB keyB, TKeyC keyC)
{
var key = TripleKey.Create(keyA, keyB, keyC);
return base.ContainsKey(key);
}
public void Add(TKeyA keyA, TKeyB keyB, TKeyC keyC, TValue value)
{
base.Add(TripleKey.Create(keyA, keyB, keyC), value);
}
}
结构类型最大的一点是因为它们继承自ValueType，它们也继承了GetHashCode方法的实现。此实现的工作方式是，对于具有相同值的任何两个结构，它们的哈希码将始终匹配（但相反并非总是如此，如果两个哈希码匹配，则没有百分之百保证所有值都相同）。
现在当我们全部安顿下来时，我们准备使用MultiKeyDictionary<TKeyA, TKeyB, TKeyC, TValue>或简单的Dictionary<TripleKey<TKeyA, TKeyB, TKeyC>, TValue>。
一个简单的例子：
var myDict = new MultiKeyDictionary<string, double, double, string>
{
{"Goodbye", 0.55, 9.00, "yaya"} // collection initializer works fine
};
myDict.Add("Hello", 1.11, 2.99, "hi");
Console.WriteLine(myDict.ContainsKey("Hello", 1.11, 2.99)); // true
Console.WriteLine(myDict.ContainsKey("a", 1.11, 2.99)); // false
Console.WriteLine(myDict["Hello", 1.11, 2.99]); // hi
myDict.Add(TripleKey.Create("Hello", 1.11, 2.99), "gh"); // bang! exception,
// key already exists
附：
正如ScottChamberlain正确指出的那样，ValueType的implementation of GetHashcode方法有其自身的优点和缺点。它使用反射，这意味着它可能会导致性能问题，因此在某些情况下最好不依赖于struct的GetHashCode实现，而是使用自定义实现覆盖它。
Eric Lippert的博客中有一篇很棒的文章叫做“Guidelines and rules for GetHashCode”。
GetHashCode方法用作“廉价”（快速）方法来测试类的两个实例是否相等。为两个相等的实例调用GetHashCode应始终产生相同的结果。因此，如果调用GetHashCode的结果对于两个实例都不相同，那么它们就不能相等，因此不必进行更详细（和更“昂贵”）的比较。
[另一方面，如果两个实例具有相同的哈希码，则需要进行更详细的比较以确定它们实际上是否相等。]
所以，除非你重新定义“等于”对你的班级意味着什么，否则你可能不需要担心GetHashCode。无论如何，你班级的“平等”概念似乎并不是很有用。
我不确定你实施的课程是否理想。因为你继承自Dictionary，你继承了一些并不真正“适合”你的类的方法。
例如，您的类现在有一个Keys方法，它返回顶级键（key1）而不是您的类实际表示的三值键。
我想知道实现聚合字典的类而不是从字典继承的类是否更好。
没有Tuple的另一个选择是定义你自己的TriKey<K1, K2, K3>类（有3个描述你的键值的属性），并且只使用Dictionary<TriKey<K1, K2, K3>, V>。在这种情况下，您绝对希望为TriKey类定义相等性，并且您需要保持GetHashCode与该相等定义一致，因为字典查找是使用它的地方之一。
最后一点，有些人可能会考虑过早优化。代码：
this[key1][key2][key3] = value;
...将对您已经获取的值执行2次查找（因为您已经访问过this[key1]和this[key1][key2]）。您可能需要考虑使用局部变量来存储这些中间结果。
例如：
MultiKeyDictionary<K2, K3, V> d1;
if (!TryGetValue(key1, out d1))
{
d1 = new MultiKeyDictionary<K2, K3, V>();
this[key1] = d1;
}
// now use d1 rather than "this[key1]"
...等等其他人。
这可能是完成你所追求的最简单的方法：
public class MultiKeyDictionary<TKey, TValue> : Dictionary<Tuple<TKey, TKey, TKey>, TValue>
{
public MultiKeyDictionary()
: base()
{
}
...
}
class Program
{
static void Main(string[] args)
{
// C# 6.0 syntax
var multiKeyDictionary = new MultiKeyDictionary<string, int>();
multiKeyDictionary.Add(Tuple.Create("key1", "key2", "key3"), 36);
// C# 7.0 syntax (not yet released).
var multiKeyDictionary1 = new MultiDictionary<string, int>();
multiKeyDictionary1.Add(("key1", "key2", "key3"), 36);
}
}
当C＃7.0发布时，您可以使用漂亮的新Tuple声明。