ReadOnlyDictionary in .NET 4.0 and 4.5

.NET 4.5 aduce destul de multe feature noi. Insa pana o sa fie adoptat pe proiectele in curs o sa treaca o perioada destul de lunga. Unele din aceste feature le putem avea si in .NET 4.0, doar ca trebuie sa scriem putin cod.
In .NET 4.5 daca avem nevoie de un dictionar care sa fie read-only este destul de simplu. Avem la dispozitie interfata IReadOnlyDictionary si implementarea acesteia. Implementarea poate sa fie gasita in namespace-ul System.Collections.Generic din 4.5.

Dictionary<int, string> dictionary = new Dictionary<int, string>();
            dictionary.Add(1, "first");
            dictionary.Add(2, "second");

            ReadOnlyDictionary<string, int> readOnlyDictionary =
                new ReadOnlyDictionary<string, int>(dictionary);

Ce este bine de stiut ca operatiile de add/edit/delete inca exista, doar ca in momentul in care acestea o sa fie apelate o sa arunce o exceptie de tip NotSupportedException.
Daca ati lucrat cu API-ul de Team Foundation, ati putut observa ca exista deja o implementare pentru acesta colecție. La fel si in API-ul de la Office 2007.
Daca nu lucram cu API-uri care au deja implementari a unui dictionar read-only, putem sa ne definim noi propia implementare. Tot ce trebuie sa facem este sa implementam interfata IDictionary care sa accepte in constructor un dictionar sau o colectie de elemente . Toate metodele care permit adaugare, modificare sau editare de elemente din dictionar nu trebuie implementate.
O alta varianta este sa va definiti si o interfata de tip IReadOnlyDictionary, care sa permita doar acces la date.
Mai jos puteti sa gasiti o implementare a unui ReadOnlyDictionary, implementand direct interfata IDictionary.

  public class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
    {
        private const string NotsupportedExceptionMessage = "This dictionary is read-only";

        private readonly IDictionary<TKey, TValue> _dictionary;

        public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary)
        {
            _dictionary = dictionary;
        }

        public void Add(TKey key, TValue value)
        {
            throw new NotSupportedException(NotsupportedExceptionMessage);
        }

        public bool ContainsKey(TKey key)
        {
            return _dictionary.ContainsKey(key);
        }

        public ICollection<TKey> Keys
        {
            get { return _dictionary.Keys; }
        }

        public bool TryGetValue(TKey key, out TValue value)
        {
            return _dictionary.TryGetValue(key, out value);
        }       

        public bool Contains(KeyValuePair<TKey, TValue> item)
        {
            return _dictionary.Contains(item);
        }

        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            _dictionary.CopyTo(array, arrayIndex);
        }

        public int Count
        {
            get { return _dictionary.Count; }
        }

        public bool IsReadOnly
        {
            get { return true; }
        }

        public TValue this[TKey key]
        {
            get
            {
                return _dictionary[key];
            }
            set
            {
                throw new NotSupportedException(NotsupportedExceptionMessage);
            }
        }

        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            return _dictionary.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return (_dictionary as System.Collections.IEnumerable).GetEnumerator();
        }

        public bool Remove(TKey key)
        {
            throw new NotSupportedException(NotsupportedExceptionMessage);
        }

        public void Add(KeyValuePair<TKey, TValue> item)
        {
            throw new NotSupportedException(NotsupportedExceptionMessage);
        }

        public void Clear()
        {
            throw new NotSupportedException(NotsupportedExceptionMessage);
        }

        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            throw new NotSupportedException(NotsupportedExceptionMessage);
        }

        public ICollection<TValue> Values
        {
            get {  throw new NotSupportedException(NotsupportedExceptionMessage); }
        }
    }