元组(或数组)作为 C # 中的字典键

我会用一个合适的 GetHashCode 覆盖你的 Tuple 然后把它当做密钥。

只要重载了正确的方法，就应该会看到良好的性能。

如果你在.NET 4.0上使用 Tuple:

lookup = new Dictionary<Tuple<TypeA, TypeB, TypeC>, string>();

如果不能，您可以定义一个 Tuple并使用它作为键。元组需要覆盖 GetHashCode、 Equals和 IEquatable:

struct Tuple<T, U, W> : IEquatable<Tuple<T,U,W>>
{
readonly T first;
readonly U second;
readonly W third;


public Tuple(T first, U second, W third)
{
this.first = first;
this.second = second;
this.third = third;
}


public T First { get { return first; } }
public U Second { get { return second; } }
public W Third { get { return third; } }


public override int GetHashCode()
{
return first.GetHashCode() ^ second.GetHashCode() ^ third.GetHashCode();
}


public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return Equals((Tuple<T, U, W>)obj);
}


public bool Equals(Tuple<T, U, W> other)
{
return other.first.Equals(first) && other.second.Equals(second) && other.third.Equals(third);
}
}

如果出于某种原因，您确实希望避免创建自己的 Tuple 类，或使用。NET 4.0，还有另一种可能的方法; 您可以将三个键值组合成一个单独的值。

例如，如果这三个值是整数类型，并且不超过64位，那么可以将它们组合成一个 ulong。

最糟糕的情况是，你总是可以使用一个字符串，只要你确保其中的三个组成部分用一些字符或序列来分隔，而这些字符或序列不会出现在密钥的组成部分中，例如，你可以尝试使用三个数字:

string.Format("{0}#{1}#{2}", key1, key2, key3)

这种方法显然存在一些组合开销，但是取决于您为此使用它的内容，这些内容可能微不足道，无需关心。

下面是.NET 元组作为参考:

[Serializable]
public class Tuple<T1, T2, T3> : IStructuralEquatable, IStructuralComparable, IComparable, ITuple {


private readonly T1 m_Item1;
private readonly T2 m_Item2;
private readonly T3 m_Item3;


public T1 Item1 { get { return m_Item1; } }
public T2 Item2 { get { return m_Item2; } }
public T3 Item3 { get { return m_Item3; } }


public Tuple(T1 item1, T2 item2, T3 item3) {
m_Item1 = item1;
m_Item2 = item2;
m_Item3 = item3;
}


public override Boolean Equals(Object obj) {
return ((IStructuralEquatable) this).Equals(obj, EqualityComparer<Object>.Default);;
}


Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer) {
if (other == null) return false;


Tuple<T1, T2, T3> objTuple = other as Tuple<T1, T2, T3>;


if (objTuple == null) {
return false;
}


return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3);
}


Int32 IComparable.CompareTo(Object obj) {
return ((IStructuralComparable) this).CompareTo(obj, Comparer<Object>.Default);
}


Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer) {
if (other == null) return 1;


Tuple<T1, T2, T3> objTuple = other as Tuple<T1, T2, T3>;


if (objTuple == null) {
throw new ArgumentException(Environment.GetResourceString("ArgumentException_TupleIncorrectType", this.GetType().ToString()), "other");
}


int c = 0;


c = comparer.Compare(m_Item1, objTuple.m_Item1);


if (c != 0) return c;


c = comparer.Compare(m_Item2, objTuple.m_Item2);


if (c != 0) return c;


return comparer.Compare(m_Item3, objTuple.m_Item3);
}


public override int GetHashCode() {
return ((IStructuralEquatable) this).GetHashCode(EqualityComparer<Object>.Default);
}


Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer) {
return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3));
}


Int32 ITuple.GetHashCode(IEqualityComparer comparer) {
return ((IStructuralEquatable) this).GetHashCode(comparer);
}
public override string ToString() {
StringBuilder sb = new StringBuilder();
sb.Append("(");
return ((ITuple)this).ToString(sb);
}


string ITuple.ToString(StringBuilder sb) {
sb.Append(m_Item1);
sb.Append(", ");
sb.Append(m_Item2);
sb.Append(", ");
sb.Append(m_Item3);
sb.Append(")");
return sb.ToString();
}


int ITuple.Size {
get {
return 3;
}
}
}

如果您的消费代码可以使用 IDictionary < > 接口，而不是 Dictionary，那么我的直觉是使用 SortedDictionary < > 和自定义数组比较器，即:

class ArrayComparer<T> : IComparer<IList<T>>
where T : IComparable<T>
{
public int Compare(IList<T> x, IList<T> y)
{
int compare = 0;
for (int n = 0; n < x.Count && n < y.Count; ++n)
{
compare = x[n].CompareTo(y[n]);
}
return compare;
}
}

然后创建如下代码(仅仅为了具体的例子而使用 int []) :

var dictionary = new SortedDictionary<int[], string>(new ArrayComparer<int>());

在基于 tuple 和嵌套字典的方法之间，基于 tuple 几乎总是更好。

从可维护性的角度来看,