ThreadSafeDictionaryTKey, TValue Class

[SerializableAttribute]
public class ThreadSafeDictionary<TKey, TValue> : IDictionary<TKey, TValue>, 
	ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
	IEnumerable, IDictionary, ICollection, ISerializable, IDeserializationCallback, 
	IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>

<SerializableAttribute>
Public Class ThreadSafeDictionary(Of TKey, TValue)
	Implements IDictionary(Of TKey, TValue), ICollection(Of KeyValuePair(Of TKey, TValue)), 
	IEnumerable(Of KeyValuePair(Of TKey, TValue)), IEnumerable, 
	IDictionary, ICollection, ISerializable, IDeserializationCallback, IReadOnlyDictionary(Of TKey, TValue), 
	IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue))

[SerializableAttribute]
generic<typename TKey, typename TValue>
public ref class ThreadSafeDictionary : IDictionary<TKey, TValue>, 
	ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
	IEnumerable, IDictionary, ICollection, ISerializable, IDeserializationCallback, 
	IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>

[<SerializableAttribute>]
type ThreadSafeDictionary<'TKey, 'TValue> = 
    class
        interface IDictionary<'TKey, 'TValue>
        interface ICollection<KeyValuePair<'TKey, 'TValue>>
        interface IEnumerable<KeyValuePair<'TKey, 'TValue>>
        interface IEnumerable
        interface IDictionary
        interface ICollection
        interface ISerializable
        interface IDeserializationCallback
        interface IReadOnlyDictionary<'TKey, 'TValue>
        interface IReadOnlyCollection<KeyValuePair<'TKey, 'TValue>>
    end

Inheritance

Object    ThreadSafeDictionaryTKey, TValue

Implements

ICollectionKeyValuePairTKey, TValue, IDictionaryTKey, TValue, IEnumerableKeyValuePairTKey, TValue, IReadOnlyCollectionKeyValuePairTKey, TValue, IReadOnlyDictionaryTKey, TValue, ICollection, IDictionary, IEnumerable, IDeserializationCallback, ISerializable

Type Parameters

TKey

Type of the keys stored in the dictionary.

TValue

Type of the values stored in the dictionary.

The purpose of ThreadSafeDictionaryTKey, TValue is similar to ConcurrentDictionaryTKey, TValue but its approach is somewhat different. The ConcurrentDictionaryTKey, TValue uses a group of locks to perform modifications (their amount can be configured or depends on the number of CPU cores); on the other hand, ThreadSafeDictionaryTKey, TValue uses two separate internal storage: items with new keys are added to a temporary storage using a single lock, which might regularly be merged into a faster lock-free storage, depending on the value of the MergeInterval property. Once the items are merged, their access (both read and write) becomes lock free. Even deleting and re-adding a value for the same key becomes faster after the key is merged into the lock-free storage.

Comparison with ConcurrentDictionaryTKey, TValue

When to use ThreadSafeDictionaryTKey, TValue:

• If it is known that a fixed set of keys will be used. ThreadSafeDictionaryTKey, TValue is fast if the already added keys are updated, or even deleted and re-added with any value. In this case consider to set the PreserveMergedKeys to , so it is not checked whether a cleanup should be performed due to many deleted items.
• If you access mainly existing keys by the AddOrUpdate methods, which are separate try get/add/update operations at ConcurrentDictionaryTKey, TValue but are optimized at ThreadSafeDictionaryTKey, TValue to avoid multiple lookups.
• If it is needed to access Count, enumerate the items or Keys/Values, or you need to call ToArray, which are particularly slow in case of ConcurrentDictionaryTKey, TValue.
• If it is expected that there will be many hash collisions.
• If the dictionary is needed to be serialized.

Performance comparison with ConcurrentDictionaryTKey, TValue (default concurrency level depends on ProcessorCount):

Incompatibilities with ConcurrentDictionaryTKey, TValue:

• Constructor signatures are different
• The Keys and Values property of ThreadSafeDictionaryTKey, TValue return wrappers for the current keys and values (enumerating the same instance again and again may yield different items), whereas ConcurrentDictionaryTKey, TValue returns a snapshot for these properties.
• The SyncRoot property of Keys and Values throw a NotSupportedException just like for their owner ThreadSafeDictionaryTKey, TValue instance. In contrast, in case of ConcurrentDictionaryTKey, TValue only the dictionary itself throws an exception when accessing the SyncRoot, whereas its keys and values don't.

Incompatibilities with DictionaryTKey, TValue:

• Constructor signatures are different, though due to default parameters they are compile-compatible.
• The ThreadSafeDictionaryTKey, TValue does not have an EnsureCapacity method.
• The GetObjectData and OnDeserialization methods are protected rather than public.
• The enumerators of the Keys and Values properties do not support the IEnumerator.Reset method.
• The SyncRoot property of Keys and Values as well as for the ThreadSafeDictionaryTKey, TValue itself throws a NotSupportedException.

Reference