I know in multithreading program, we need to use ConcurrentDictionary, ConcurrentBag etc those thread-safe collection. But in my situation, the number of keys in Dictionary is fixed, I have exact 5 keys which I already know before the program executes so I can initialize the dictionary's key. So my thinking is, because the number of the keys is not going to change, I can actually use Dictionary instead of ConcurrentDictionary, and the reason I am thinking to do this, is because the collection won't resize internally, so there won't be a situation when thread1 try to update an element after thread2 adds a new element then cause resizing, which makes thread1's update fail. Is my understanding correct?
More information:
I don't have a shared key/value pair that can be updated by all threads, each thread just update a particular key/value pair and TKey is a unique string, TValue is simple class type
The documentation of the Dictionary<TKey, TValue> class states explicitly that:
To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.
So, based on the documentation, if you modify the dictionary by multiple threads without synchronization, you have entered the "undefined behavior" territory. Meaning that "anything" can happen, and whatever happens will not be a bug. The warranty has been breached, and Microsoft couldn't care less about any damages that have occurred to you, after using their products incorrectly.
That said, and knowing how the Dictionary<TKey, TValue> class is implemented, it's unlikely that you'll have any issues by using a Dictionary<TKey, TValue> in a lock-free manner, if you follow the very strict usage pattern that you describe in your question. It's up to you decide if it's OK to rely on implementation details of the API that you use, instead of the published documentation.
As a side note, be aware that in general searching serially for a value in a small List<T> or array outperforms searching for a value in a small hash-based Dictionary<TKey, TValue>. The tipping point depends on the type of the key, and might be as large as 50 elements or more. Also for storing one value per thread, you might find the ThreadLocal<T> class useful.
If
then locking in the current implementation is not needed (i.e. Dictionary is fine) because the dictionary itself doesn't change and a single consumer accesses each value.
Generally, it is not OK to use code which works but uses structures that have better alternatives for a given scenario. Code like this is very easy to break without knowing until it is deployed in a real life scenario and even then it's hard to find out the issue quickly.