Ashkru Ashkru - 1 month ago 8
C# Question

When should I use ConcurrentDictionary and Dictionary?

I'm always confused on which one of these to pick. As I see it I use

Dictionary
over
List
if I want two data types as a
Key
and
Value
so I can easily find a value by its
key
but I am always confused if I should use a
ConcurrentDictionary
or
Dictionary
?

Before you go off at me for not putting much research in to this I have tried, but it seems google hasn't really got anything on
Dictionary
vs
ConcurrentDictionary
but has something on each one individually.

I have asked a friend this before but all they said is: "use
ConcurrentDictionary
if you use your dictionary a lot in code" and I didn't really want to pester them in to explaining it in larger detail. Could anyone expand on this?

Answer Source

"Use ConcurrentDictionary if you use your dictionary a lot in code" is kind of vague advice. I don't blame you for the confusion.

ConcurrentDictionary is primary for use in an environment where you'd updating the dictionary from multiple threads (or async tasks). You can use a standard Dictionary from as much code as you like if it's from a single thread ;)

If you look at the methods on a ConcurrentDictionary, you'll spot some interesting methods like TryAdd, TryGetValue, TryUpdate, and TryRemove.

For example, consider a typical pattern you might see for working with a normal Dictionary class.

// There are better ways to do this... but we need an example ;)
if (!dictionary.ContainsKey(id))
    dictionary.Add(id, value);

This has an issue in that between the check for whether it contains a key and calling Add a different thread could call Add with that same id. When this thread calls Add, it'll throw an exception. The method TryAdd handles that for you and will return a true/false telling you whether it added it (or whether that key was already in the dictionary).

So unless you're working in a multi-threaded section of code, you probably can just use the standard Dictionary class. That being said, you could theoretically have locks to prevent concurrent access to a dictionary; that question is already address in "Dictionary locking vs. ConcurrentDictionary".