.NET 4.5 Read-Only Interfaces


In the preceding hierarchical diagram you can see core generic interfaces and read-only interface. I assume you are familiar with core generic interfaces, so here I'm not discussing more about them. Read-only interfaces were introduced only recently with .NET 4.5 They essentially have all the functionality for modifying collections from generic interfaces removed, letting you expose interfaces to other code without any risk of that code being able to use those interfaces to modify collections.

Look at the read-only part of the hierarchy. The read-only interfaces start with an interface called IReadOnlyCollection that mirrors ICollection. We saw that the main branch splits into three at this point. The read-only interfaces do the same thing except that there's no read-only equivalent of ISet. The only read-only interfaces are IReadOnlyList and IReadOnlyDictionary. As i said earlier, read-only interfaces do not expose anything to modify the collection.


This is a very simple interface. We can start from ICollection. You can see the ICollection interface in the following sample.

Remove all the stuff to do the modification of the collection and we also remove the Contains() and CopyTo() methods.

So what are we left with? Yes, the Count property. IReadOnlyCollection is an enumerable that also knows how many elements it has and I think that's potentially rather a nice interface to have available.



IRedOnlyList follows the spirit of IReadOnlyCollection. It adds those IList methods that are read-only and unambiguously useful and this is the result. You get IReadOnlyCollection plus the indexer, but only read-only access and that's it. In the following picuture you can see the IReadOnlyList<T> interface.


IReadOnlyDictionary<TKey, TValue>

IReadOnlyDictionary is unusually for the read-only interfaces and is quite powerful. It contains all the added functionality of IDictionary except obviously for the ability to add or remove items. In the following sample you can see the IDictionary interface.

You can see the IReadOnlyDictionary<Tkey,TValue> interface below.

  1. public interface IReadOnlyDictionary < TKey, TValue > : IReadOnlyCollection < KeyValuePair < TKey,  
  2. TValue >> ,  
  3. IEnumerable < KeyValuePair < TKey,  
  4. TValue >> ,  
  5. IEnumerable  
  6.   {  
  7.     IEnumerable < TKey > Keys  
  8.     {  
  9.         get;  
  10.     }  
  11.     IEnumerable < TValue > Values  
  12.     {  
  13.         get;  
  14.     }  
  15.     TValue this[TKey key]  
  16.     {  
  17.         get;  
  18.     }  
  19.     bool ContainsKey(TKey key);  
  20.     bool TryGetValue(TKey key, out TValue value);  

The IReadOnlyDictionary<Tkey,TValue> interface looks quite nice and useful if you want to expose read-only functionality on a Dictionary.


Read-only interfaces look quite nice and useful if you want to expose read-only functionality on core generic type interfaces like ICollection<T>, IList<T> and IDictionary<Tkey,Tvalue>.