BiDirectional Dictionary

I had the need for a dictionary in a personal project recently, but I ran into a bit of a snag.  I needed to be able to look up values from either direction.  That is, both forward (Key to Value) and backward (Value to Key).  Your standard C# Dictionary out of the box doesn't support this behavior.

Fortunately I happened across a good solution from another blogger, Tim Barrass (Bidirectional Lookup).  So, I began implementing it and then writing unit tests to cover it.  In the process I uncovered a couple issues with adding new items and removing them that I corrected.  So, here's the updated dictionary:

The changes are pretty straight-forward:

1. Changed the secondList.ToList().Add(second); and firstList.ToList().Add(first); calls on lines 49 and 50 to Append to the IEnumerable<> and also to re-assign to the internal dictionaries.
2. Rewrote the entire Remove() function to remove from the internal lists and if its the last entry remove the keys as well.

Code Snippet

13. public class BidirectionalDictionary<TFirst, TSecond>
14. {
15.     private IDictionary<TFirst, IEnumerable<TSecond>> Forward { get; set; }
16.     private IDictionary<TSecond, IEnumerable<TFirst>> Backward { get; set; }
17.  
18.     private static readonly IEnumerable<TFirst> EmptyFirstList = new List<TFirst>();
19.     private static readonly IEnumerable<TSecond> EmptySecondList = new List<TSecond>();
20.  
21.     public BidirectionalDictionary(IDictionary<TFirst, IEnumerable<TSecond>> forward, IDictionary<TSecond, IEnumerable<TFirst>> backward)
22.     {
23.         Forward = forward;
24.         Backward = backward;
25.     }
26.  
27.     public BidirectionalDictionary()
28.     {
29.         Forward = new Dictionary<TFirst, IEnumerable<TSecond>>();
30.         Backward = new Dictionary<TSecond, IEnumerable<TFirst>>();
31.     }
32.  
33.     public void Add(TFirst first, TSecond second)
34.     {
35.         IEnumerable<TSecond> secondList;
36.         if (!Forward.TryGetValue(first, out secondList))
37.         {
38.             secondList = new List<TSecond>();
39.             Forward[first] = secondList;
40.         }
41.  
42.         IEnumerable<TFirst> firstList;
43.         if (!Backward.TryGetValue(second, out firstList))
44.         {
45.             firstList = new List<TFirst>();
46.             Backward[second] = firstList;
47.         }
48.  
49.         Forward[first] = secondList.Append(second);
50.         Backward[second] = firstList.Append(first);
51.     }
52.  
53.     public IEnumerable<TSecond> GetByFirst(TFirst first)
54.     {
55.         return Forward.ContainsKey(first) ? Forward[first] : EmptySecondList;
56.     }
57.  
58.     public IEnumerable<TFirst> GetBySecond(TSecond second)
59.     {
60.         return Backward.ContainsKey(second) ? Backward[second] : EmptyFirstList;
61.     }
62.  
63.     public void Remove(TFirst first, TSecond second)
64.     {
65.         IEnumerable<TSecond> secondList;
66.         if (Forward.TryGetValue(first, out secondList))
67.         {
68.             if (secondList.Contains(second))
69.             {
70.                 secondList.ToList().Remove(second);
71.                 if (secondList.Any())
72.                     Forward[first] = secondList;
73.                 else
74.                     Forward.Remove(first);
75.             }
76.             else
77.                 Forward.Remove(first);
78.         }
79.  
80.         IEnumerable<TFirst> firstList;
81.         if (Backward.TryGetValue(second, out firstList))
82.         {
83.             if (firstList.Contains(first))
84.             {
85.                 firstList.ToList().Remove(first);
86.                 if (firstList.Any())
87.                     Backward[second] = firstList;
88.                 else
89.                     Backward.Remove(second);
90.             }
91.             else
92.                 Backward.Remove(second);
93.         }
94.     }
95. }

And now the unit tests surrounding this code. I used NUnit for this project and as you can see covered nearly all of the behavior within the new class.

Code Snippet

8. [TestFixture]
9. public class BidirectionalDictionaryTests
10. {
11.     private static BidirectionalDictionary<string, string> _dictionary;
12.         
13.     [SetUp]
14.     private void OnSetup()
15.     {
16.         _dictionary = new BidirectionalDictionary<string, string>();
17.         _dictionary.Add("FirstValue", "FirstLookupValue");
18.     }
19.  
20.     [TestCase("FirstValue", "FirstLookupValue", true)]
21.     [TestCase("SecondValue", "FirstLookupValue", false)]
22.     public void GetByFirstTest(string firstValue, string secondValue, bool expectedResult)
23.     {
24.         var results = _dictionary.GetByFirst(firstValue);
25.  
26.         Assert.That(results.ToList().Contains(secondValue), Is.EqualTo(expectedResult));
27.     }
28.  
29.     [TestCase("SecondValue", "FirstLookupValue", true)]
30.     [TestCase("SecondLookupValue", "FirstLookupValue", false)]
31.     public void GetBySecondTest(string secondValue, string firstValue, bool expectedResult)
32.     {
33.         var results = _dictionary.GetBySecond(secondValue);
34.  
35.         Assert.That(results.ToList().Contains(firstValue), Is.EqualTo(expectedResult));
36.     }
37.  
38.     [Test]
39.     public void Remove_Test()
40.     {
41.         _dictionary.Remove("FirstValue", "FirstLookupValue");
42.  
43.         var results = _dictionary.GetByFirst("FirstValue");
44.  
45.         Assert.That(results.ToList().Contains("FirstValue"), Is.False);
46.  
47.         results = _dictionary.GetBySecond("FirstLookupValue");
48.  
49.         Assert.That(results.ToList().Contains("FirstLookupValue"), Is.False);
50.     }
51. }

Again, I want to thank Tim Barrass for the initial work on this dictionary. I hope this is helpful to anyone else as its worked great for me.