SynchronizedDictionary Class

.NET API Reference for Oracle® Coherence Community Edition
(14.1.1.0)
E55634-01

Synchronized IDictionary wrapper that uses read/write locks to synchronize access to the underlying dictionary.

Inheritance Hierarchy

SystemObject
Tangosol.Util.CollectionsSynchronizedDictionary
Tangosol.Net.CacheLocalCache

Namespace: Tangosol.Util.Collections
Assembly: Coherence (in Coherence.dll) Version: 14.1.1.1 (14.1.1.1)

Syntax

Copy

[SerializableAttribute]
public class SynchronizedDictionary : IDictionary, 
	ICollection, IEnumerable, ISerializable

The SynchronizedDictionary type exposes the following members.

Constructors

	Name	Description
	SynchronizedDictionary	Create SynchronizedDictionary instance.
	SynchronizedDictionary(IDictionary)	specified dictionary.
	SynchronizedDictionary(Int32)	Create SynchronizedDictionary instance.
	SynchronizedDictionary(SerializationInfo, StreamingContext)	Initializes a new instance of the SynchronizedDictionary class using the specified SerializationInfo and StreamingContext.

Top

Properties

	Name	Description
	Count	Gets the number of key/value pairs in this dictionary.
	Delegate	Return the delegate IDictionary.
	IsFixedSize	Get a value indicating whether this dictionary has a fixed size.
	IsReadLockHeld	Determines whether or not the current thread holds a read lock.
	IsReadOnly	Get a value indicating whether this dictionary is read-only.
	IsSynchronized	Gets a value indicating whether access to this dictionary is thread-safe.
	IsWriteLockHeld	Determines whether or not the current thread holds the write lock.
	Item	Get or set the value associated with the specified key.
	Keys	Get a collection containing the keys in this dictionary.
	SyncRoot	Get an object that can be used to synchronize access to this dictionary.
	Values	Get a collection containing the values in this dictionary.

Top

Methods

	Name	Description
	AcquireReadLock	Acquire a read lock.
	AcquireReadLock(Int32)	Acquire a read lock.
	AcquireWriteLock	Acquire a write lock.
	AcquireWriteLock(Int32)	Acquire a write lock.
	Add	Add an entry with the specified key and value to this dictionary.
	Clear	Remove all entries from this dictionary.
	Contains	Determine whether this dictionary contains the specified key.
	CopyTo	Copy entries from this dictionary into the one-dimensional array.
	Equals	Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
	Finalize	Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)
	GetEnumerator	Return an IDictionaryEnumerator that iterates through this dictionary.
	GetHashCode	Serves as a hash function for a particular type. (Inherited from Object.)
	GetObjectData	Populates SerializationInfo with the data needed to serialize this object.
	GetType	Gets the Type of the current instance. (Inherited from Object.)
	MemberwiseClone	Creates a shallow copy of the current Object. (Inherited from Object.)
	ReleaseReadLock	Release a read lock.
	ReleaseWriteLock	Release a write lock.
	Remove	Remove the entrty with the specified key from this dictionary.
	ToString	Returns a string that represents the current object. (Inherited from Object.)

Top

Fields

	Name	Description
	m_dict	Wrapped, non-thread safe dictionary.

Top

Remarks

This class uses read/write locks to ensure that only a single thread can modify the underlying dictionary at any given time, while allowing concurrent reads by multiple threads.

While all individual operations exposed by this class are thread-safe, you may still need to synchronize access to an instance of this class if you need to perform multiple operations atomically.

In order to do that, you can do one of the following:

Lock the SyncRoot property. Because the write locks used internally also lock SyncRoot, this will prevent concurrent modification. However, concurrent read operations will still be allowed, which means that other threads will be able to see partial updates. If you need truly atomic multi-operation updates, you should use write locks instead.
Use read locks. By acquiring a read lock externally, you can ensure that no modifications take place while you are reading from the dictionary. See AcquireReadLock for details.
Use write locks. By acquiring a write lock, you can achieve complete isolation and fully atomic multi-operation updates, as no other thread will be able to either read from or write to the dictionary until the write lock is released. See AcquireWriteLock for details.

Note 1: If you attempt to acquire a write lock on a thread that holds a read lock, the read lock will be promoted to a write lock as soon as all read locks held by other threads are released.

Note 2: The enumerator returned by the GetEnumerator method is not thread-safe. You should either acquire a read lock or lock the SyncRoot explicitly if you need to enumerate dictionary entries in a thread-safe manner.

Note 3: This class has been renamed from SynchronizedHashtable to SynchronizedDictionary in Coherence 3.5, to better reflect the fact that it can be used to wrap any IDictionary implementation.

Reference

Tangosol.Util.Collections Namespace