Question

I was able to implement a thread-safe Dictionary in C# by deriving from IDictionary and defining a private SyncRoot object:

public class SafeDictionary<TKey, TValue>: IDictionary<TKey, TValue> {     private readonly object syncRoot = new object();     private Dictionary<TKey, TValue> d = new Dictionary<TKey, TValue>();      public object SyncRoot     {         get { return syncRoot; }     }       public void Add(TKey key, TValue value)     {         lock (syncRoot)         {             d.Add(key, value);         }     }      // more IDictionary members... } 

I then lock on this SyncRoot object throughout my consumers (multiple threads):

Example:

lock (m_MySharedDictionary.SyncRoot) {     m_MySharedDictionary.Add(...); } 

I was able to make it work, but this resulted in some ugly code. My question is, is there a better, more elegant way of implementing a thread-safe Dictionary?

Answer 1

As Peter said, you can encapsulate all of the thread safety inside the class. You will need to be careful with any events you expose or add, making sure that they get invoked outside of any locks.

public class SafeDictionary<TKey, TValue>: IDictionary<TKey, TValue> {     private readonly object syncRoot = new object();     private Dictionary<TKey, TValue> d = new Dictionary<TKey, TValue>();      public void Add(TKey key, TValue value)     {         lock (syncRoot)         {             d.Add(key, value);         }         OnItemAdded(EventArgs.Empty);     }      public event EventHandler ItemAdded;      protected virtual void OnItemAdded(EventArgs e)     {         EventHandler handler = ItemAdded;         if (handler != null)             handler(this, e);     }      // more IDictionary members... } 

Edit: The MSDN docs point out that enumerating is inherently not thread safe. That can be one reason for exposing a synchronization object outside your class. Another way to approach that would be to provide some methods for performing an action on all members and lock around the enumerating of the members. The problem with this is that you don’t know if the action passed to that function calls some member of your dictionary (that would result in a deadlock). Exposing the synchronization object allows the consumer to make those decisions and doesn’t hide the deadlock inside your class.