C#中的双向1对1字典
Posted
技术标签:
【中文标题】C#中的双向1对1字典【英文标题】：Bidirectional 1 to 1 Dictionary in C# 【发布时间】：2010-09-21 01:34:05 【问题描述】：我正在寻找 C# (2) 中的通用双向 1 对 1 字典类，即。 BiDictionaryOneToOne<T, S> 保证只包含每个值和键中的一个（最多 RefEquals 无论如何），并且可以使用键或值进行搜索。任何人都知道一个，还是我应该自己实现它？我不敢相信我是第一个需要这个的人......
this question 的答案中有一个 BiDictionary，但它不适用于唯一元素（也没有实现 RemoveByFirst(T t) 或 RemoveBySecond(S s)）。
谢谢！
【问题讨论】：
相关：***.com/questions/255341/… 【参考方案1】：好的，这是我的尝试（建立在 Jon 的基础上 - 谢谢），存档在这里并开放供改进：
/// <summary>
/// This is a dictionary guaranteed to have only one of each value and key.
/// It may be searched either by TFirst or by TSecond, giving a unique answer because it is 1 to 1.
/// </summary>
/// <typeparam name="TFirst">The type of the "key"</typeparam>
/// <typeparam name="TSecond">The type of the "value"</typeparam>
public class BiDictionaryOneToOne<TFirst, TSecond>
IDictionary<TFirst, TSecond> firstToSecond = new Dictionary<TFirst, TSecond>();
IDictionary<TSecond, TFirst> secondToFirst = new Dictionary<TSecond, TFirst>();
#region Exception throwing methods
/// <summary>
/// Tries to add the pair to the dictionary.
/// Throws an exception if either element is already in the dictionary
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
public void Add(TFirst first, TSecond second)
if (firstToSecond.ContainsKey(first) || secondToFirst.ContainsKey(second))
throw new ArgumentException("Duplicate first or second");
firstToSecond.Add(first, second);
secondToFirst.Add(second, first);
/// <summary>
/// Find the TSecond corresponding to the TFirst first
/// Throws an exception if first is not in the dictionary.
/// </summary>
/// <param name="first">the key to search for</param>
/// <returns>the value corresponding to first</returns>
public TSecond GetByFirst(TFirst first)
TSecond second;
if (!firstToSecond.TryGetValue(first, out second))
throw new ArgumentException("first");
return second;
/// <summary>
/// Find the TFirst corresponing to the Second second.
/// Throws an exception if second is not in the dictionary.
/// </summary>
/// <param name="second">the key to search for</param>
/// <returns>the value corresponding to second</returns>
public TFirst GetBySecond(TSecond second)
TFirst first;
if (!secondToFirst.TryGetValue(second, out first))
throw new ArgumentException("second");
return first;
/// <summary>
/// Remove the record containing first.
/// If first is not in the dictionary, throws an Exception.
/// </summary>
/// <param name="first">the key of the record to delete</param>
public void RemoveByFirst(TFirst first)
TSecond second;
if (!firstToSecond.TryGetValue(first, out second))
throw new ArgumentException("first");
firstToSecond.Remove(first);
secondToFirst.Remove(second);
/// <summary>
/// Remove the record containing second.
/// If second is not in the dictionary, throws an Exception.
/// </summary>
/// <param name="second">the key of the record to delete</param>
public void RemoveBySecond(TSecond second)
TFirst first;
if (!secondToFirst.TryGetValue(second, out first))
throw new ArgumentException("second");
secondToFirst.Remove(second);
firstToSecond.Remove(first);
#endregion
#region Try methods
/// <summary>
/// Tries to add the pair to the dictionary.
/// Returns false if either element is already in the dictionary
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
/// <returns>true if successfully added, false if either element are already in the dictionary</returns>
public Boolean TryAdd(TFirst first, TSecond second)
if (firstToSecond.ContainsKey(first) || secondToFirst.ContainsKey(second))
return false;
firstToSecond.Add(first, second);
secondToFirst.Add(second, first);
return true;
/// <summary>
/// Find the TSecond corresponding to the TFirst first.
/// Returns false if first is not in the dictionary.
/// </summary>
/// <param name="first">the key to search for</param>
/// <param name="second">the corresponding value</param>
/// <returns>true if first is in the dictionary, false otherwise</returns>
public Boolean TryGetByFirst(TFirst first, out TSecond second)
return firstToSecond.TryGetValue(first, out second);
/// <summary>
/// Find the TFirst corresponding to the TSecond second.
/// Returns false if second is not in the dictionary.
/// </summary>
/// <param name="second">the key to search for</param>
/// <param name="first">the corresponding value</param>
/// <returns>true if second is in the dictionary, false otherwise</returns>
public Boolean TryGetBySecond(TSecond second, out TFirst first)
return secondToFirst.TryGetValue(second, out first);
/// <summary>
/// Remove the record containing first, if there is one.
/// </summary>
/// <param name="first"></param>
/// <returns> If first is not in the dictionary, returns false, otherwise true</returns>
public Boolean TryRemoveByFirst(TFirst first)
TSecond second;
if (!firstToSecond.TryGetValue(first, out second))
return false;
firstToSecond.Remove(first);
secondToFirst.Remove(second);
return true;
/// <summary>
/// Remove the record containing second, if there is one.
/// </summary>
/// <param name="second"></param>
/// <returns> If second is not in the dictionary, returns false, otherwise true</returns>
public Boolean TryRemoveBySecond(TSecond second)
TFirst first;
if (!secondToFirst.TryGetValue(second, out first))
return false;
secondToFirst.Remove(second);
firstToSecond.Remove(first);
return true;
#endregion
/// <summary>
/// The number of pairs stored in the dictionary
/// </summary>
public Int32 Count
get return firstToSecond.Count;
/// <summary>
/// Removes all items from the dictionary.
/// </summary>
public void Clear()
firstToSecond.Clear();
secondToFirst.Clear();
【讨论】：
作为一个建议，我认为为了获得更大的健壮性，您需要将所有操作视为 SQL 事务的等效项。例如，如果 firstToSecond.Add() 抛出异常，Add() 中的整体字典状态会发生什么？ 糟糕——这应该是关于如果 secondToFirst,Add() 失败/抛出异常会发生什么。 Dictionary 什么时候会抛出异常？如果另一种方法是在出现异常时保留预添加字典的副本，以便在 finally 块中替换它们，那么也许可以让它在不检查的情况下失败。还是签入 finally 块并在失败时抛出异常？ 我发现添加 [Serializable] 属性很有用（例如存储在 Session 中） @aolszowka 支付罚款比使用异常作为逻辑机制更好。规则是在特殊情况下捕获异常。 Btw, in case the exceptions are caught multiple times in a loop, checking for existence is faster.【参考方案2】：更完整的双向字典实现：
支持原始Dictionary<TKey,TValue> 的几乎所有接口（基础设施接口除外）：
IDictionary<TKey, TValue>
IReadOnlyDictionary<TKey, TValue>
IDictionary
ICollection<KeyValuePair<TKey, TValue>>（这个及以下是上面的基础接口）
ICollection
IReadOnlyCollection<KeyValuePair<TKey, TValue>>
IEnumerable<KeyValuePair<TKey, TValue>>
IEnumerable
序列化使用SerializableAttribute。
调试视图使用DebuggerDisplayAttribute（带有计数信息）和DebuggerTypeProxyAttribute（用于在手表中显示键值对）。
反向字典可用作IDictionary<TValue, TKey> Reverse 属性，并且还实现了上述所有接口。任一字典上的所有操作都会修改两者。
用法：
var dic = new BiDictionary<int, string>();
dic.Add(1, "1");
dic[2] = "2";
dic.Reverse.Add("3", 3);
dic.Reverse["4"] = 4;
dic.Clear();
代码在我在 GitHub 上的私有框架中可用：BiDictionary(TFirst,TSecond).cs (permalink, search)。
复制：
[Serializable]
[DebuggerDisplay ("Count = Count"), DebuggerTypeProxy (typeof(DictionaryDebugView<,>))]
public class BiDictionary<TFirst, TSecond> : IDictionary<TFirst, TSecond>, IReadOnlyDictionary<TFirst, TSecond>, IDictionary
private readonly IDictionary<TFirst, TSecond> _firstToSecond = new Dictionary<TFirst, TSecond>();
[NonSerialized]
private readonly IDictionary<TSecond, TFirst> _secondToFirst = new Dictionary<TSecond, TFirst>();
[NonSerialized]
private readonly ReverseDictionary _reverseDictionary;
public BiDictionary ()
_reverseDictionary = new ReverseDictionary(this);
public IDictionary<TSecond, TFirst> Reverse
get return _reverseDictionary;
public int Count
get return _firstToSecond.Count;
object ICollection.SyncRoot
get return ((ICollection)_firstToSecond).SyncRoot;
bool ICollection.IsSynchronized
get return ((ICollection)_firstToSecond).IsSynchronized;
bool IDictionary.IsFixedSize
get return ((IDictionary)_firstToSecond).IsFixedSize;
public bool IsReadOnly
get return _firstToSecond.IsReadOnly || _secondToFirst.IsReadOnly;
public TSecond this [TFirst key]
get return _firstToSecond[key];
set
_firstToSecond[key] = value;
_secondToFirst[value] = key;
object IDictionary.this [object key]
get return ((IDictionary)_firstToSecond)[key];
set
((IDictionary)_firstToSecond)[key] = value;
((IDictionary)_secondToFirst)[value] = key;
public ICollection<TFirst> Keys
get return _firstToSecond.Keys;
ICollection IDictionary.Keys
get return ((IDictionary)_firstToSecond).Keys;
IEnumerable<TFirst> IReadOnlyDictionary<TFirst, TSecond>.Keys
get return ((IReadOnlyDictionary<TFirst, TSecond>)_firstToSecond).Keys;
public ICollection<TSecond> Values
get return _firstToSecond.Values;
ICollection IDictionary.Values
get return ((IDictionary)_firstToSecond).Values;
IEnumerable<TSecond> IReadOnlyDictionary<TFirst, TSecond>.Values
get return ((IReadOnlyDictionary<TFirst, TSecond>)_firstToSecond).Values;
public IEnumerator<KeyValuePair<TFirst, TSecond>> GetEnumerator ()
return _firstToSecond.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator ()
return GetEnumerator();
IDictionaryEnumerator IDictionary.GetEnumerator ()
return ((IDictionary)_firstToSecond).GetEnumerator();
public void Add (TFirst key, TSecond value)
_firstToSecond.Add(key, value);
_secondToFirst.Add(value, key);
void IDictionary.Add (object key, object value)
((IDictionary)_firstToSecond).Add(key, value);
((IDictionary)_secondToFirst).Add(value, key);
public void Add (KeyValuePair<TFirst, TSecond> item)
_firstToSecond.Add(item);
_secondToFirst.Add(item.Reverse());
public bool ContainsKey (TFirst key)
return _firstToSecond.ContainsKey(key);
public bool Contains (KeyValuePair<TFirst, TSecond> item)
return _firstToSecond.Contains(item);
public bool TryGetValue (TFirst key, out TSecond value)
return _firstToSecond.TryGetValue(key, out value);
public bool Remove (TFirst key)
TSecond value;
if (_firstToSecond.TryGetValue(key, out value))
_firstToSecond.Remove(key);
_secondToFirst.Remove(value);
return true;
else
return false;
void IDictionary.Remove (object key)
var firstToSecond = (IDictionary)_firstToSecond;
if (!firstToSecond.Contains(key))
return;
var value = firstToSecond[key];
firstToSecond.Remove(key);
((IDictionary)_secondToFirst).Remove(value);
public bool Remove (KeyValuePair<TFirst, TSecond> item)
return _firstToSecond.Remove(item);
public bool Contains (object key)
return ((IDictionary)_firstToSecond).Contains(key);
public void Clear ()
_firstToSecond.Clear();
_secondToFirst.Clear();
public void CopyTo (KeyValuePair<TFirst, TSecond>[] array, int arrayIndex)
_firstToSecond.CopyTo(array, arrayIndex);
void ICollection.CopyTo (Array array, int index)
((IDictionary)_firstToSecond).CopyTo(array, index);
[OnDeserialized]
internal void OnDeserialized (StreamingContext context)
_secondToFirst.Clear();
foreach (var item in _firstToSecond)
_secondToFirst.Add(item.Value, item.Key);
private class ReverseDictionary : IDictionary<TSecond, TFirst>, IReadOnlyDictionary<TSecond, TFirst>, IDictionary
private readonly BiDictionary<TFirst, TSecond> _owner;
public ReverseDictionary (BiDictionary<TFirst, TSecond> owner)
_owner = owner;
public int Count
get return _owner._secondToFirst.Count;
object ICollection.SyncRoot
get return ((ICollection)_owner._secondToFirst).SyncRoot;
bool ICollection.IsSynchronized
get return ((ICollection)_owner._secondToFirst).IsSynchronized;
bool IDictionary.IsFixedSize
get return ((IDictionary)_owner._secondToFirst).IsFixedSize;
public bool IsReadOnly
get return _owner._secondToFirst.IsReadOnly || _owner._firstToSecond.IsReadOnly;
public TFirst this [TSecond key]
get return _owner._secondToFirst[key];
set
_owner._secondToFirst[key] = value;
_owner._firstToSecond[value] = key;
object IDictionary.this [object key]
get return ((IDictionary)_owner._secondToFirst)[key];
set
((IDictionary)_owner._secondToFirst)[key] = value;
((IDictionary)_owner._firstToSecond)[value] = key;
public ICollection<TSecond> Keys
get return _owner._secondToFirst.Keys;
ICollection IDictionary.Keys
get return ((IDictionary)_owner._secondToFirst).Keys;
IEnumerable<TSecond> IReadOnlyDictionary<TSecond, TFirst>.Keys
get return ((IReadOnlyDictionary<TSecond, TFirst>)_owner._secondToFirst).Keys;
public ICollection<TFirst> Values
get return _owner._secondToFirst.Values;
ICollection IDictionary.Values
get return ((IDictionary)_owner._secondToFirst).Values;
IEnumerable<TFirst> IReadOnlyDictionary<TSecond, TFirst>.Values
get return ((IReadOnlyDictionary<TSecond, TFirst>)_owner._secondToFirst).Values;
public IEnumerator<KeyValuePair<TSecond, TFirst>> GetEnumerator ()
return _owner._secondToFirst.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator ()
return GetEnumerator();
IDictionaryEnumerator IDictionary.GetEnumerator ()
return ((IDictionary)_owner._secondToFirst).GetEnumerator();
public void Add (TSecond key, TFirst value)
_owner._secondToFirst.Add(key, value);
_owner._firstToSecond.Add(value, key);
void IDictionary.Add (object key, object value)
((IDictionary)_owner._secondToFirst).Add(key, value);
((IDictionary)_owner._firstToSecond).Add(value, key);
public void Add (KeyValuePair<TSecond, TFirst> item)
_owner._secondToFirst.Add(item);
_owner._firstToSecond.Add(item.Reverse());
public bool ContainsKey (TSecond key)
return _owner._secondToFirst.ContainsKey(key);
public bool Contains (KeyValuePair<TSecond, TFirst> item)
return _owner._secondToFirst.Contains(item);
public bool TryGetValue (TSecond key, out TFirst value)
return _owner._secondToFirst.TryGetValue(key, out value);
public bool Remove (TSecond key)
TFirst value;
if (_owner._secondToFirst.TryGetValue(key, out value))
_owner._secondToFirst.Remove(key);
_owner._firstToSecond.Remove(value);
return true;
else
return false;
void IDictionary.Remove (object key)
var firstToSecond = (IDictionary)_owner._secondToFirst;
if (!firstToSecond.Contains(key))
return;
var value = firstToSecond[key];
firstToSecond.Remove(key);
((IDictionary)_owner._firstToSecond).Remove(value);
public bool Remove (KeyValuePair<TSecond, TFirst> item)
return _owner._secondToFirst.Remove(item);
public bool Contains (object key)
return ((IDictionary)_owner._secondToFirst).Contains(key);
public void Clear ()
_owner._secondToFirst.Clear();
_owner._firstToSecond.Clear();
public void CopyTo (KeyValuePair<TSecond, TFirst>[] array, int arrayIndex)
_owner._secondToFirst.CopyTo(array, arrayIndex);
void ICollection.CopyTo (Array array, int index)
((IDictionary)_owner._secondToFirst).CopyTo(array, index);
internal class DictionaryDebugView<TKey, TValue>
private readonly IDictionary<TKey, TValue> _dictionary;
[DebuggerBrowsable (DebuggerBrowsableState.RootHidden)]
public KeyValuePair<TKey, TValue>[] Items
get
var array = new KeyValuePair<TKey, TValue>[_dictionary.Count];
_dictionary.CopyTo(array, 0);
return array;
public DictionaryDebugView (IDictionary<TKey, TValue> dictionary)
if (dictionary == null)
throw new ArgumentNullException("dictionary");
_dictionary = dictionary;
public static class KeyValuePairExts
public static KeyValuePair<TValue, TKey> Reverse<TKey, TValue> (this KeyValuePair<TKey, TValue> @this)
return new KeyValuePair<TValue, TKey>(@this.Value, @this.Key);
【讨论】：
很遗憾您的 github 链接已损坏。 我在您的item.Reverse 行收到编译错误。有什么特定的版本要求吗？
@NicolasRaoul 你没有复制代码sn-p底部的KeyValuePairExts类。【参考方案3】：
您提到的问题还在this answer 中显示了一对一的实现。添加 RemoveByFirst 和 RemoveBySecond 将是微不足道的 - 实现额外的接口等也是如此。
【讨论】：
好的，很公平，我已经这样做了。完成单元测试后，我会将其添加到答案中...【参考方案4】：这与接受的答案相同，但我也提供了 Update 方法，而且总体上更加充实：
public class BiDictionary<TKey1, TKey2> : IEnumerable<Tuple<TKey1, TKey2>>
Dictionary<TKey1, TKey2> _forwards;
Dictionary<TKey2, TKey1> _reverses;
public int Count
get
if (_forwards.Count != _reverses.Count)
throw new Exception("somewhere logic went wrong and your data got corrupt");
return _forwards.Count;
public ICollection<TKey1> Key1s
get return _forwards.Keys;
public ICollection<TKey2> Key2s
get return _reverses.Keys;
public BiDictionary(IEqualityComparer<TKey1> comparer1 = null, IEqualityComparer<TKey2> comparer2 = null)
_forwards = new Dictionary<TKey1, TKey2>(comparer1);
_reverses = new Dictionary<TKey2, TKey1>(comparer2);
public bool ContainsKey1(TKey1 key)
return ContainsKey(key, _forwards);
private static bool ContainsKey<S, T>(S key, Dictionary<S, T> dict)
return dict.ContainsKey(key);
public bool ContainsKey2(TKey2 key)
return ContainsKey(key, _reverses);
public TKey2 GetValueByKey1(TKey1 key)
return GetValueByKey(key, _forwards);
private static T GetValueByKey<S, T>(S key, Dictionary<S, T> dict)
return dict[key];
public TKey1 GetValueByKey2(TKey2 key)
return GetValueByKey(key, _reverses);
public bool TryGetValueByKey1(TKey1 key, out TKey2 value)
return TryGetValue(key, _forwards, out value);
private static bool TryGetValue<S, T>(S key, Dictionary<S, T> dict, out T value)
return dict.TryGetValue(key, out value);
public bool TryGetValueByKey2(TKey2 key, out TKey1 value)
return TryGetValue(key, _reverses, out value);
public bool Add(TKey1 key1, TKey2 key2)
if (ContainsKey1(key1) || ContainsKey2(key2)) // very important
return false;
AddOrUpdate(key1, key2);
return true;
public void AddOrUpdateByKey1(TKey1 key1, TKey2 key2)
if (!UpdateByKey1(key1, key2))
AddOrUpdate(key1, key2);
// dont make this public; a dangerous method used cautiously in this class
private void AddOrUpdate(TKey1 key1, TKey2 key2)
_forwards[key1] = key2;
_reverses[key2] = key1;
public void AddOrUpdateKeyByKey2(TKey2 key2, TKey1 key1)
if (!UpdateByKey2(key2, key1))
AddOrUpdate(key1, key2);
public bool UpdateKey1(TKey1 oldKey, TKey1 newKey)
return UpdateKey(oldKey, _forwards, newKey, (key1, key2) => AddOrUpdate(key1, key2));
private static bool UpdateKey<S, T>(S oldKey, Dictionary<S, T> dict, S newKey, Action<S, T> updater)
T otherKey;
if (!TryGetValue(oldKey, dict, out otherKey) || ContainsKey(newKey, dict))
return false;
Remove(oldKey, dict);
updater(newKey, otherKey);
return true;
public bool UpdateKey2(TKey2 oldKey, TKey2 newKey)
return UpdateKey(oldKey, _reverses, newKey, (key1, key2) => AddOrUpdate(key2, key1));
public bool UpdateByKey1(TKey1 key1, TKey2 key2)
return UpdateByKey(key1, _forwards, _reverses, key2, (k1, k2) => AddOrUpdate(k1, k2));
private static bool UpdateByKey<S, T>(S key1, Dictionary<S, T> forwards, Dictionary<T, S> reverses, T key2,
Action<S, T> updater)
T otherKey;
if (!TryGetValue(key1, forwards, out otherKey) || ContainsKey(key2, reverses))
return false;
if (!Remove(otherKey, reverses))
throw new Exception("somewhere logic went wrong and your data got corrupt");
updater(key1, key2);
return true;
public bool UpdateByKey2(TKey2 key2, TKey1 key1)
return UpdateByKey(key2, _reverses, _forwards, key1, (k1, k2) => AddOrUpdate(k2, k1));
public bool RemoveByKey1(TKey1 key)
return RemoveByKey(key, _forwards, _reverses);
private static bool RemoveByKey<S, T>(S key, Dictionary<S, T> keyDict, Dictionary<T, S> valueDict)
T otherKey;
if (!TryGetValue(key, keyDict, out otherKey))
return false;
if (!Remove(key, keyDict) || !Remove(otherKey, valueDict))
throw new Exception("somewhere logic went wrong and your data got corrupt");
return true;
private static bool Remove<S, T>(S key, Dictionary<S, T> dict)
return dict.Remove(key);
public bool RemoveByKey2(TKey2 key)
return RemoveByKey(key, _reverses, _forwards);
public void Clear()
_forwards.Clear();
_reverses.Clear();
public IEnumerator<Tuple<TKey1, TKey2>> GetEnumerator()
if (_forwards.Count != _reverses.Count)
throw new Exception("somewhere logic went wrong and your data got corrupt");
foreach (var item in _forwards)
yield return Tuple.Create(item.Key, item.Value);
IEnumerator IEnumerable.GetEnumerator()
return GetEnumerator();
类似于我的回答here
注意事项：
我只实现了IEnumerable<>。我认为ICollection<> 在这里没有意义，因为对于这种特殊的集合结构，方法名称都可能完全不同。由您决定 IEnumerable<> 里面应该放什么。所以现在你也有了集合初始化语法，比如
var p = new BiDictionary<int, string> 1, "a" , 2, "b" ;
我试图在这里和那里抛出一些奇怪的异常 - 只是为了数据完整性。只是为了更安全，以便您知道我的代码是否有错误。
性能：您可以使用Keys 中的任何一个查找Value，这意味着Get 和Contains 方法只需要1 次查找(O(1))。 Add 需要 2 次查找和 2 次添加。 Update 需要 1 次查找和 2 次添加。 Remove 需要 3 次查找。都与接受的答案相似。
【讨论】：
看起来 IEnumerable 也可以通过像这样answer 反映到成员的实现来实现 我在这里用过IEnumerator<Tuple<TKey1, TKey2>>。不是IEnumerator<KeyValuePair<TKey1, TKey2>>，所以我认为我不能对我的 GetEnumerator 函数这样做。我没听错吗？
我现在看到了接口继承中声明的元组。只需注意标准字典使用 KVP。
标准字典应该使用 kvp，因为它是键和值的映射。它更好地传达了意思。而如果双向字典使用 kvp，那么它仅意味着键值关系，而不是相反。我承认元组在这里并不是最合适的，因为它暗示 value1 和 value2 之间根本没有关系，但我发现它仍然比 kvp 更好，因为它不那么令人困惑。【参考方案5】：
我已经创建了这样一个类，使用 C5 集合类。
public class Mapper<K,T> : IEnumerable<T>
C5.TreeDictionary<K,T> KToTMap = new TreeDictionary<K,T>();
C5.HashDictionary<T,K> TToKMap = new HashDictionary<T,K>();
/// <summary>
/// Initializes a new instance of the Mapper class.
/// </summary>
public Mapper()
KToTMap = new TreeDictionary<K,T>();
TToKMap = new HashDictionary<T,K>();
public void Add(K key, T value)
KToTMap.Add(key, value);
TToKMap.Add(value, key);
public bool ContainsKey(K key)
return KToTMap.Contains(key);
public int Count
get return KToTMap.Count;
public K this[T obj]
get
return TToKMap[obj];
public T this[K obj]
get
return KToTMap[obj];
public IEnumerator<T> GetEnumerator()
return KToTMap.Values.GetEnumerator();
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
return KToTMap.Values.GetEnumerator();
【讨论】：
你为什么要一个树字典和一个哈希字典？有什么区别？ 当两种类型相同并且您尝试恢复一个值时会发生什么？例如： var primes = new Mapper已接受答案的另一个扩展。它实现了 IEnumerable，因此可以使用 foreach 。我意识到 IEnumerable 实现有更多答案，但这个使用结构，所以它是垃圾收集器友好。 这在 Unity 引擎中特别有用（通过分析器检查）。
/// <summary>
/// This is a dictionary guaranteed to have only one of each value and key.
/// It may be searched either by TFirst or by TSecond, giving a unique answer because it is 1 to 1.
/// It implements garbage-collector-friendly IEnumerable.
/// </summary>
/// <typeparam name="TFirst">The type of the "key"</typeparam>
/// <typeparam name="TSecond">The type of the "value"</typeparam>
public class BiDictionary<TFirst, TSecond> : IEnumerable<BiDictionary<TFirst, TSecond>.Pair>
public struct Pair
public TFirst First;
public TSecond Second;
public struct Enumerator : IEnumerator<Pair>, IEnumerator
public Enumerator(Dictionary<TFirst, TSecond>.Enumerator dictEnumerator)
_dictEnumerator = dictEnumerator;
public Pair Current
get
Pair pair;
pair.First = _dictEnumerator.Current.Key;
pair.Second = _dictEnumerator.Current.Value;
return pair;
object IEnumerator.Current
get
return Current;
public void Dispose()
_dictEnumerator.Dispose();
public bool MoveNext()
return _dictEnumerator.MoveNext();
public void Reset()
throw new NotSupportedException();
private Dictionary<TFirst, TSecond>.Enumerator _dictEnumerator;
#region Exception throwing methods
/// <summary>
/// Tries to add the pair to the dictionary.
/// Throws an exception if either element is already in the dictionary
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
public void Add(TFirst first, TSecond second)
if (_firstToSecond.ContainsKey(first) || _secondToFirst.ContainsKey(second))
throw new ArgumentException("Duplicate first or second");
_firstToSecond.Add(first, second);
_secondToFirst.Add(second, first);
/// <summary>
/// Find the TSecond corresponding to the TFirst first
/// Throws an exception if first is not in the dictionary.
/// </summary>
/// <param name="first">the key to search for</param>
/// <returns>the value corresponding to first</returns>
public TSecond GetByFirst(TFirst first)
TSecond second;
if (!_firstToSecond.TryGetValue(first, out second))
throw new ArgumentException("first");
return second;
/// <summary>
/// Find the TFirst corresponing to the Second second.
/// Throws an exception if second is not in the dictionary.
/// </summary>
/// <param name="second">the key to search for</param>
/// <returns>the value corresponding to second</returns>
public TFirst GetBySecond(TSecond second)
TFirst first;
if (!_secondToFirst.TryGetValue(second, out first))
throw new ArgumentException("second");
return first;
/// <summary>
/// Remove the record containing first.
/// If first is not in the dictionary, throws an Exception.
/// </summary>
/// <param name="first">the key of the record to delete</param>
public void RemoveByFirst(TFirst first)
TSecond second;
if (!_firstToSecond.TryGetValue(first, out second))
throw new ArgumentException("first");
_firstToSecond.Remove(first);
_secondToFirst.Remove(second);
/// <summary>
/// Remove the record containing second.
/// If second is not in the dictionary, throws an Exception.
/// </summary>
/// <param name="second">the key of the record to delete</param>
public void RemoveBySecond(TSecond second)
TFirst first;
if (!_secondToFirst.TryGetValue(second, out first))
throw new ArgumentException("second");
_secondToFirst.Remove(second);
_firstToSecond.Remove(first);
#endregion
#region Try methods
/// <summary>
/// Tries to add the pair to the dictionary.
/// Returns false if either element is already in the dictionary
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
/// <returns>true if successfully added, false if either element are already in the dictionary</returns>
public bool TryAdd(TFirst first, TSecond second)
if (_firstToSecond.ContainsKey(first) || _secondToFirst.ContainsKey(second))
return false;
_firstToSecond.Add(first, second);
_secondToFirst.Add(second, first);
return true;
/// <summary>
/// Find the TSecond corresponding to the TFirst first.
/// Returns false if first is not in the dictionary.
/// </summary>
/// <param name="first">the key to search for</param>
/// <param name="second">the corresponding value</param>
/// <returns>true if first is in the dictionary, false otherwise</returns>
public bool TryGetByFirst(TFirst first, out TSecond second)
return _firstToSecond.TryGetValue(first, out second);
/// <summary>
/// Find the TFirst corresponding to the TSecond second.
/// Returns false if second is not in the dictionary.
/// </summary>
/// <param name="second">the key to search for</param>
/// <param name="first">the corresponding value</param>
/// <returns>true if second is in the dictionary, false otherwise</returns>
public bool TryGetBySecond(TSecond second, out TFirst first)
return _secondToFirst.TryGetValue(second, out first);
/// <summary>
/// Remove the record containing first, if there is one.
/// </summary>
/// <param name="first"></param>
/// <returns> If first is not in the dictionary, returns false, otherwise true</returns>
public bool TryRemoveByFirst(TFirst first)
TSecond second;
if (!_firstToSecond.TryGetValue(first, out second))
return false;
_firstToSecond.Remove(first);
_secondToFirst.Remove(second);
return true;
/// <summary>
/// Remove the record containing second, if there is one.
/// </summary>
/// <param name="second"></param>
/// <returns> If second is not in the dictionary, returns false, otherwise true</returns>
public bool TryRemoveBySecond(TSecond second)
TFirst first;
if (!_secondToFirst.TryGetValue(second, out first))
return false;
_secondToFirst.Remove(second);
_firstToSecond.Remove(first);
return true;
#endregion
/// <summary>
/// The number of pairs stored in the dictionary
/// </summary>
public Int32 Count
get return _firstToSecond.Count;
/// <summary>
/// Removes all items from the dictionary.
/// </summary>
public void Clear()
_firstToSecond.Clear();
_secondToFirst.Clear();
public Enumerator GetEnumerator()
//enumerator.Reset(firstToSecond.GetEnumerator());
return new Enumerator(_firstToSecond.GetEnumerator());
IEnumerator<Pair> IEnumerable<Pair>.GetEnumerator()
return GetEnumerator();
IEnumerator IEnumerable.GetEnumerator()
return GetEnumerator();
private Dictionary<TFirst, TSecond> _firstToSecond = new Dictionary<TFirst, TSecond>();
private Dictionary<TSecond, TFirst> _secondToFirst = new Dictionary<TSecond, TFirst>();
【讨论】：
这个答案的要点：gist.github.com/…【参考方案7】：有点晚了，但这是我不久前写的一个实现。它处理一些有趣的边缘情况，例如当键覆盖相等检查以执行部分相等时。这导致主字典存储A => 1，但反向存储1 => A'。
您通过Inverse 属性访问逆字典。
var map = new BidirectionalDictionary<int, int>();
map.Add(1, 2);
var result = map.Inverse[2]; // result is 1
//
// BidirectionalDictionary.cs
//
// Author:
// Chris Chilvers <chilversc@googlemail.com>
//
// Copyright (c) 2009 Chris Chilvers
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Generic;
namespace Cadenza.Collections
public class BidirectionalDictionary<TKey, TValue> : IDictionary<TKey, TValue>
private readonly IEqualityComparer<TKey> keyComparer;
private readonly IEqualityComparer<TValue> valueComparer;
private readonly Dictionary<TKey, TValue> keysToValues;
private readonly Dictionary<TValue, TKey> valuesToKeys;
private readonly BidirectionalDictionary<TValue, TKey> inverse;
public BidirectionalDictionary () : this (10, null, null)
public BidirectionalDictionary (int capacity) : this (capacity, null, null)
public BidirectionalDictionary (IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
: this (10, keyComparer, valueComparer)
public BidirectionalDictionary (int capacity, IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
if (capacity < 0)
throw new ArgumentOutOfRangeException ("capacity", capacity, "capacity cannot be less than 0");
this.keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;
this.valueComparer = valueComparer ?? EqualityComparer<TValue>.Default;
keysToValues = new Dictionary<TKey, TValue> (capacity, this.keyComparer);
valuesToKeys = new Dictionary<TValue, TKey> (capacity, this.valueComparer);
inverse = new BidirectionalDictionary<TValue, TKey> (this);
private BidirectionalDictionary (BidirectionalDictionary<TValue, TKey> inverse)
this.inverse = inverse;
keyComparer = inverse.valueComparer;
valueComparer = inverse.keyComparer;
valuesToKeys = inverse.keysToValues;
keysToValues = inverse.valuesToKeys;
public BidirectionalDictionary<TValue, TKey> Inverse
get return inverse;
public ICollection<TKey> Keys
get return keysToValues.Keys;
public ICollection<TValue> Values
get return keysToValues.Values;
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator ()
return keysToValues.GetEnumerator ();
IEnumerator IEnumerable.GetEnumerator ()
return GetEnumerator ();
void ICollection<KeyValuePair<TKey, TValue>>.CopyTo (KeyValuePair<TKey, TValue>[] array, int arrayIndex)
((ICollection<KeyValuePair<TKey, TValue>>) keysToValues).CopyTo (array, arrayIndex);
public bool ContainsKey (TKey key)
if (key == null)
throw new ArgumentNullException ("key");
return keysToValues.ContainsKey (key);
public bool ContainsValue (TValue value)
if (value == null)
throw new ArgumentNullException ("value");
return valuesToKeys.ContainsKey (value);
bool ICollection<KeyValuePair<TKey, TValue>>.Contains (KeyValuePair<TKey, TValue> item)
return ((ICollection<KeyValuePair<TKey, TValue>>) keysToValues).Contains (item);
public bool TryGetKey (TValue value, out TKey key)
if (value == null)
throw new ArgumentNullException ("value");
return valuesToKeys.TryGetValue (value, out key);
public bool TryGetValue (TKey key, out TValue value)
if (key == null)
throw new ArgumentNullException ("key");
return keysToValues.TryGetValue (key, out value);
public TValue this[TKey key]
get return keysToValues [key];
set
if (key == null)
throw new ArgumentNullException ("key");
if (value == null)
throw new ArgumentNullException ("value");
//foo[5] = "bar"; foo[6] = "bar"; should not be valid
//as it would have to remove foo[5], which is unexpected.
if (ValueBelongsToOtherKey (key, value))
throw new ArgumentException ("Value already exists", "value");
TValue oldValue;
if (keysToValues.TryGetValue (key, out oldValue))
// Use the current key for this value to stay consistent
// with Dictionary<TKey, TValue> which does not alter
// the key if it exists.
TKey oldKey = valuesToKeys [oldValue];
keysToValues [oldKey] = value;
valuesToKeys.Remove (oldValue);
valuesToKeys [value] = oldKey;
else
keysToValues [key] = value;
valuesToKeys [value] = key;
public int Count
get return keysToValues.Count;
bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
get return false;
public void Add (TKey key, TValue value)
if (key == null)
throw new ArgumentNullException ("key");
if (value == null)
throw new ArgumentNullException ("value");
if (keysToValues.ContainsKey (key))
throw new ArgumentException ("Key already exists", "key");
if (valuesToKeys.ContainsKey (value))
throw new ArgumentException ("Value already exists", "value");
keysToValues.Add (key, value);
valuesToKeys.Add (value, key);
public void Replace (TKey key, TValue value)
if (key == null)
throw new ArgumentNullException ("key");
if (value == null)
throw new ArgumentNullException ("value");
// replaces a key value pair, if the key or value already exists those mappings will be replaced.
// e.g. you have; a -> b, b -> a; c -> d, d -> c
// you add the mapping; a -> d, d -> a
// this will remove both of the original mappings
Remove (key);
inverse.Remove (value);
Add (key, value);
void ICollection<KeyValuePair<TKey, TValue>>.Add (KeyValuePair<TKey, TValue> item)
Add (item.Key, item.Value);
public bool Remove (TKey key)
if (key == null)
throw new ArgumentNullException ("key");
TValue value;
if (keysToValues.TryGetValue (key, out value))
keysToValues.Remove (key);
valuesToKeys.Remove (value);
return true;
else
return false;
bool ICollection<KeyValuePair<TKey, TValue>>.Remove (KeyValuePair<TKey, TValue> item)
bool removed = ((ICollection<KeyValuePair<TKey, TValue>>) keysToValues).Remove (item);
if (removed)
valuesToKeys.Remove (item.Value);
return removed;
public void Clear ()
keysToValues.Clear ();
valuesToKeys.Clear ();
private bool ValueBelongsToOtherKey (TKey key, TValue value)
TKey otherKey;
if (valuesToKeys.TryGetValue (value, out otherKey))
// if the keys are not equal the value belongs to another key
return !keyComparer.Equals (key, otherKey);
else
// value doesn't exist in map, thus it cannot belong to another key
return false;
Original source 和 tests 在 github 上。
【讨论】：
以上是关于C#中的双向1对1字典的主要内容，如果未能解决你的问题，请参考以下文章