Home Library Learn Downloads Support Community
Sign in | United States - English | |
This topic has not yet been rated - Rate this topic

SynchronizedReadOnlyCollection<T> Class

.NET Framework 3.5

Provides a thread-safe, read-only collection that contains objects of a type specified by the generic parameter as elements.

Namespace:  System.Collections.Generic
Assembly:  System.ServiceModel (in System.ServiceModel.dll)
C#
C++
JScript
VB
Copy 
[ComVisibleAttribute(false)]
public class SynchronizedReadOnlyCollection<T> : IList<T>, 
	ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable

Type Parameters

T

The type of object contained as items in the thread-safe, read-only collection.

The SynchronizedReadOnlyCollection<T> stores data in an IList<T> container and provides an object that can be set and used to synchronize access to the collection so that it is thread safe. The IList<T> container can be recovered using the Items property. The synchronized object can be recovered using the SyncRoot() property. It can only be set using one of the constructors that take the syncRoot parameter.

System.Object
  System.Collections.Generic.SynchronizedReadOnlyCollection<T>
Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 7, Windows Vista, Windows XP SP2, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0
Did you find this helpful?
(1500 characters remaining)
Community Content Add
Annotations FAQ
Provides a thread-safe, read-only view to consumers, while still allowing modification underneath
This collection is useful when you need to provide a read-only version of a collection to consumers, while still being able to modify the underlying storage in a thread-safe manner.

For example, the following code shows a thread-safe scenario where Borrower.BorrowedBooks returns a read-only collection, while still allowing the Borrower.Borrow and Borrower.Return methods to modify the underlying collection safely.

[C#}

public class LibraryBook
{
    public LibraryBook()
    {
    }
}

public class ReadOnlyLibraryBookCollection : SynchronizedReadOnlyCollection<LibraryBook>
{
    internal ReadOnlyLibraryBookCollection()
    {
    }





















    private object Lock
    {
        get { return ((ICollection)this).SyncRoot; }
    }
    internal void Add(LibraryBook book)
    {
        lock (Lock)
        {
            Items.Add(book);
        }
    }
    internal void Remove(LibraryBook book)
    {
        lock (Lock)
        {
            Items.Remove(book);
        }
    }
}

public class Borrower
{
    private ReadOnlyLibraryBookCollection _BorrowedBooks = new ReadOnlyLibraryBookCollection();
    // Thread-safe for reading from
    public ReadOnlyLibraryBookCollection BorrowedBooks
    {
        get { return _BorrowedBooks; }
    }
    public void Borrow(LibraryBook book)
    {
        // Thread-safe add
        _BorrowedBooks.Add(book);
    }
    public void Return(LibraryBook book)
    {
        // Thread-safe remove
        _BorrowedBooks.Remove(book);
    }
}

Note: Although the above ReadOnlyLibraryBookCollection class is safe for reading from and writing to, it is not safe for enumeration. That is, during a foreach (For Each in Visual Basic) block or direct usage of the IEnumerator<LibraryBook> returned from ReadOnlyLibraryBookCollection.GetEnumerator, nothing stops another thread from modifying the collection (and thereby causing an InvalidOperationException to be throw) by calling Borrower.Borrow or Borrower.Return.
History