Est-ce que C# ont une façon de me donner un immuable Dictionnaire?

Question

Est-il rien de construit dans le noyau C# bibliothèques qui peut me donner une immuable Dictionnaire?

Quelque chose le long des lignes de Java:

Collections.unmodifiableMap(myMap);

Et juste pour préciser, je ne cherche pas à arrêter les clés / valeurs elles-mêmes d'être changé, juste la structure du Dictionnaire. Je veux quelque chose qui ne parvient pas rapide et fort si l'un de IDictionary du mutateur méthodes sont appelées (Add, Remove, Clear).

Answer 1

Non, mais un wrapper est assez triviale:

public class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
    IDictionary<TKey, TValue> _dict;

    public ReadOnlyDictionary(IDictionary<TKey, TValue> backingDict)
    {
        _dict = backingDict;
    }

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

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

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

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

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

    public ICollection<TValue> Values
    {
        get { return _dict.Values; }
    }

    public TValue this[TKey key]
    {
        get { return _dict[key]; }
        set { throw new InvalidOperationException(); }
    }

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

    public void Clear()
    {
        throw new InvalidOperationException();
    }

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

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

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

    public bool IsReadOnly
    {
        get { return true; }
    }

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

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

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

Évidemment, vous pouvez changer la ce[] setter ci-dessus si vous voulez vous permettent de modifier les valeurs.

Answer 2

Autant que je sache, il n'y est pas. Mais peut-être vous pouvez copier une partie du code (et d'apprendre beaucoup) de ces articles:

L'immutabilité en C# première Partie: les Genres de l'Immuabilité
L'immutabilité en C# Partie Deux: Un Simple Immuable de la Pile
L'immutabilité en C# troisième Partie: Un Covariant Immuable de la Pile
L'immutabilité en C# Partie Quatre: Un Immuable de la File d'attente
L'immutabilité en C# sixième Partie: Un Simple Arbre Binaire
L'immutabilité en C# septième Partie: Plus sur des Arbres Binaires
L'immutabilité en C# huitième Partie: de plus en Plus Sur des Arbres Binaires
L'immutabilité en C# la Partie Neuf: Académique? De Plus, mon arbre AVL de mise en œuvre
L'immutabilité en C# Partie 10: Un double-clos de la file d'attente
L'immutabilité en C# onzième Partie: Un travail à double extrémité de la file d'attente

Answer 3

Avec la sortie de la .NET 4.5, il y a un nouveau ReadOnlyDictionary classe. Il vous suffit de passer un IDictionary pour le constructeur pour créer l'immuable dictionnaire.

Ici est un utile méthode d'extension qui peuvent être utilisés pour simplifier la création de la readonly dictionnaire.

Answer 4

L'open-source PowerCollections bibliothèque comprend la lecture du dictionnaire wrapper (ainsi que la lecture seule des wrappers pour à peu près tout le reste), accessible via un statique ReadOnly() méthode sur l' Algorithms classe.

Answer 5

Je ne le pense pas. Il existe un moyen de créer une Liste en lecture seule et en lecture seule Collection, mais je ne pense pas qu'il y a un construit en lecture seule Dictionnaire. Système.ServiceModel a un ReadOnlyDictinoary mise en œuvre, mais son intérieur. Ne serait probablement pas être trop difficile à copier, à l'aide de Réflecteur, ou tout simplement créer votre propre à partir de zéro. Essentiellement, il emballe un Dictionnaire et déclenche lorsqu'un mutateur est appelé.