I was wondering if there was a built in type in C# that was like 'Dictionary' but where both TKey and TValue had to be unique.
For example::
d.Add(1, "1");
d.Add(2, "1"); // This would not be OK because "1" has already been used as a value.
I know this is kind of exotic, but it seems that since there are about a billion collection types in the BCL it might exist. Any ideas?
How about having Dictionary and HashSet/secondary reverse Dictionary - it will solve the issue and will perform better than checks on single Dictionary.
Something like this, wrapped as class:
HashSet<string> secondary = new HashSet<string>(/*StringComparer.InvariantCultureIgnoreCase*/);
Dictionary<int, string>dictionary = new Dictionary<int, string>();
object syncer = new object();
public override void Add(int key, string value)
{
lock(syncer)
{
if(dictionary.ContainsKey(key))
{
throw new Exception("Key already exists");
}
if(secondary.Add(value)
{
throw new Exception("Value already exists");
}
dictionary.Add(key, value);
}
}
I solved this issue by storing the data as Dictionary<TKey, HashSet<TValue>>.
You can replace the HashSet by another Dictionary if you want a value that has 2 primary keys.
Dictionary<int, HashSet<int>> _myUniquePairOfIntegerKeys;
// OR
Dictionary<string, Dictionary<string, bool>> _myUniquePairOfStringKeysWithABooleanValue;
For internal puposes I wrote a BiDictionary. It isn't bullet-proof by I don't expose it to the user so it works fine for me. It allows to me get either key as I ofter need to.
The KeyPair<,> is necessary to be able to implement the IEnumerable<,> and thus the Add method so that we can use the object initializer.
internal class KeyPair<TKey1, TKey2>
{
public TKey1 Key1 { get; set; }
public TKey2 Key2 { get; set; }
}
This is the main class as a dynamic object so that we can use key names on it when retrieving values:
internal class BiDictionary<TKey1, TKey2> : DynamicObject, IEnumerable<KeyPair<TKey1, TKey2>>
{
private readonly Dictionary<TKey1, TKey2> _K1K2 = new Dictionary<TKey1, TKey2>();
private readonly Dictionary<TKey2, TKey1> _K2K1 = new Dictionary<TKey2, TKey1>();
private readonly string _key1Name;
private readonly string _key2Name;
public BiDictionary(string key1Name, string key2Name)
{
_key1Name = key1Name;
_key2Name = key2Name;
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
if (binder.Name == _key1Name)
{
result = _K1K2;
return true;
}
if (binder.Name == _key2Name)
{
result = _K2K1;
return true;
}
result = null;
return false;
}
public void Add(TKey1 key1, TKey2 key2)
{
_K1K2.Add(key1, key2);
_K2K1.Add(key2, key1);
}
public IEnumerator<KeyPair<TKey1, TKey2>> GetEnumerator()
{
return _K1K2.Zip(_K2K1, (d1, d2) => new KeyPair<TKey1, TKey2>
{
Key1 = d1.Key,
Key2 = d2.Key
}).GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
Example:
dynamic bidic = new BiDictionary<string, string>("Key1", "Key2")
{
{ "foo", "bar" },
{ "baz", "qux" }
};
var bar = bidic.Key1["foo"];
var foo = bidic.Key2["bar"];
They may go out of sync if you modify any of the dictionaries outside. For this purpose I use ObservableDictionary so that I can update the other one if one changes but for the sake of simplicity I removed this part of the code to just demostrate the main logic.
There is a project located here that has a type like this. It is called PairDictionary and it works pretty well. Not the best answer, but for anyone who needs that custom class.
You could implement an extension method that skips adding to the dictionary if a given value already exists.
static class Extensions
{
public static void AddSafe(this Dictionary<int, string> dictionary, int key, string value)
{
if (!dictionary.ContainsValue(value))
dictionary.Add(key, value);
}
}
Call it like a normal function
d.AddSafe(1, "1");
d.AddSafe(2, "1"); // This would not add anything
