"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 primarily for use in an environment where you're 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 addressed in "Dictionary locking vs. ConcurrentDictionary".
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…