ThreadSafeHashSetT Class

[SerializableAttribute]
public class ThreadSafeHashSet<T> : ICollection<T>, 
	IEnumerable<T>, IEnumerable, ICollection, ISerializable, IDeserializationCallback, 
	IReadOnlyCollection<T>

<SerializableAttribute>
Public Class ThreadSafeHashSet(Of T)
	Implements ICollection(Of T), IEnumerable(Of T), 
	IEnumerable, ICollection, ISerializable, IDeserializationCallback, IReadOnlyCollection(Of T)

[SerializableAttribute]
generic<typename T>
public ref class ThreadSafeHashSet : ICollection<T>, 
	IEnumerable<T>, IEnumerable, ICollection, ISerializable, IDeserializationCallback, 
	IReadOnlyCollection<T>

[<SerializableAttribute>]
type ThreadSafeHashSet<'T> = 
    class
        interface ICollection<'T>
        interface IEnumerable<'T>
        interface IEnumerable
        interface ICollection
        interface ISerializable
        interface IDeserializationCallback
        interface IReadOnlyCollection<'T>
    end

Inheritance

Object    ThreadSafeHashSetT

Implements

ICollectionT, IEnumerableT, IReadOnlyCollectionT, ICollection, IEnumerable, IDeserializationCallback, ISerializable

Type Parameters

T

Type of the items stored in the ThreadSafeHashSetT.

ThreadSafeHashSetT uses a very similar approach to ThreadSafeDictionaryTKey, TValue. It uses two separate internal storage: new items 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 an item becomes faster after it has been merged into the lock-free storage.

Comparison with other thread-safe collections.

When to prefer ThreadSafeHashSetT over ConcurrentDictionaryTKey, TValue:

• If you would use only the keys, without any value.
• If it is known that a fixed number of items will be used, or Contains will be used much more often than Add, in which case ThreadSafeHashSetT may become mainly lock-free.
• If the same set of items are deleted and re-added again and again. In this case consider to set the PreserveMergedItems to , so it is not checked whether a cleanup should be performed due to many deleted items.
• If it is needed to access Count, enumerate the items 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 collection is needed to be serialized.

When to prefer LockingCollectionT over ThreadSafeHashSetT:

• If you just need a wrapper for an already existing ICollectionT without copying the actual items.
• If you just need a simple thread-safe solution without additional allocations (unless if you enumerate the collection) and it's not a problem if it cannot scale well for high concurrency.

Incompatibilities with HashSetT:

• Some of the constructors have different parameters.
• ThreadSafeHashSetT does not implement the ISetT interface because most of its members make little sense when the instance is used concurrently.
• It has no public CopyTo methods. The ICollection<T>.CopyTo method is implemented explicitly, though it is not recommended to use it because when elements are added or removed during the operation you cannot tell how many elements were actually copied. Use the ToArray method instead, which works in all circumstances.

Reference