Dictionnaire vraiment immuable dans .NET

Voici un design très rapide, probablement ne compilera probablement pas tout de suite, mais j'espère vous donner quelques idées ...

[Immutable]
class ImmutableDictionary<TKey, TValue> : Dictionary<TKey, TValue>
{
    public ImmutableDictionary(IEnumerable<KeyValuePair<TKey, TValue>> keysValues)
    {
        // Ensure TKey is immutable...
        if (typeof(TKey).GetCustomAttribute(typeof(ImmutableAttribute), false).Length == 0)
            throw new InvalidOperationException(String.Format("Type '{0}' must be immutable.", typeof(TKey).AssemblyQualifiedName);

        // Ensure TValue is immutable...
        if (typeof(TValue).GetCustomAttribute(typeof(ImmutableAttribute), false).Length == 0)
            throw new InvalidOperationException(String.Format("Type '{0}' must be immutable.", typeof(TValue).AssemblyQualifiedName);

        foreach(var keyValue in keysValues)
            base.Add(keyValue.Key, keyValue.Value);
    }

    public new void Add(TKey key, TValue value)
    {
        throw new InvalidOperationException("Cannot modify contents of immutable dictionary.");
    }

    public new void Clear()
    {
        throw new InvalidOperationException("Cannot modify contents of immutable dictionary.");
    }

    public new void Remove(TKey key)
    {
        throw new InvalidOperationException("Cannot modify contents of immutable dictionary.");
    }

    public TValue this[TKey key]
    {
        get { return base[key]; }
        set
        {
            throw new InvalidOperationException("Cannot modify contents of immutable dictionary.");
        }
    }
}

Si alors Thkey et TValue sont des types de valeur, vous pouvez créer un dictionnaire vraiment immuable, dans le sens où ni sa structure interne ni les valeurs elles-mêmes ne peuvent changer, si ces paramètres sont des types de types de référence et que les valeurs peuvent facilement être modifiées, changeant ainsi le dictionnaire lui-même. Ai-je raison?

Pas exactement. Vous avez identifié un vrai problème, mais votre caractérisalisation n'est pas complètement réfléchie.

Tout d'abord, je note que oui, un type de valeur bloqué dans un dictionnaire immuable est immuable, même s'il s'agit d'un type de valeur mutable. Pourquoi? Parce que les types de valeur ne sont mutés que par mutation de la variable qui les contient. Si votre dictionnaire n'expose pas les variables utilisées pour stocker les types de valeur, les variables ne sont pas modifiées.

Cependant, même si un type de valeur est lui-même immutable un type de valeur immuable peut contenir une référence à un type de référence mutable , et maintenant nous avons le même problème. La limitation du dictionnaire des types de valeurs ne pousse que le problème d'un niveau, il ne le résout pas! Ce que vous avez vraiment besoin de garantir une immuabilité "Deep" est un dictionnaire des types de valeur blustables . Par "blittable", je veux dire un type de valeur sans champs de type de référence. (Considérons par soi-disant parce que vous pouvez sérialiser l'un de ceux-ci au stockage en "blâmant" les bits directement sur le disque.)

Malheureusement, il n'y a pas de contrainte dans le système de type générique pour contraindre à des types de valeur blistables.

Prenons maintenant le problème général des types de référence mutables dans un dictionnaire immuable, que ces types de référence sont là directement ou via un champ de type de valeur. Ce qui peut se tromper si un type de référence est muté hors bande alors qu'il est dans un dictionnaire immuable?

Eh bien, la première chose qui vous vient à l'esprit est qu'un dictionnaire immuable devrait donner la même réponse deux fois à la même question à la même question, et cela n'est plus le cas. Si vous dites «clients [nom] .Address», vous vous attendez à obtenir la même réponse deux fois, mais si le client est un type de référence pouvant être muté, vous obtiendrez une réponse potentiellement différente. Cela pourrait ou pourrait ne pas être souhaitable. (Et note que le dictionnaire donne la même réponse deux fois: il donne la même référence à l'objet client. C'est en fait l'objet client qui ne donne pas la même réponse deux fois.)

En supposant que vous n'essayez pas de mémoialiser les réponses aux questions qui peuvent changer, ce n'est généralement pas un gros problème.

Un problème plus important est quand un objet qui se trouve dans une table de hachage sous forme de mutation de clé, modifiant ainsi sa valeur de hachage et "Perdre" l'objet dans la table.

Si cela se produit, une personne ne garde pas dans les directives. Les lignes directrices sont (1) Les types de référence devraient si possible ne pas baser leurs codes de hachage (et l'égalité) sur des données pouvant être muté et (2) un objet utilisé comme clé dans une table de hachage ne doit pas être muté.