Imbriquée collection de dictionnaires en .NET

Avoir une exigence pour la arbitrairement long de nidification, je suis venu avec la solution suivante, qui, autant que je peux voir, ne casse pas, selon mon test:

public class NestedDictionary<K, V> : Dictionary<K, NestedDictionary<K, V>>
    {
        public V Value { set; get; }

        public new NestedDictionary<K, V> this[K key]
        {
            set { base[key] = value; }

            get
            {
                if (!base.Keys.Contains<K>(key))
                {
                    base[key] = new NestedDictionary<K, V>();
                }
                return base[key];
            }
        }
    }

TEST:

NestedDictionary<string, string> dict = new NestedDictionary<string, string>();
dict["one"].Value = "Nest level 1";
dict["one"]["two"]["three"].Value = "Nest level 3";
dict["FieldA"]["FieldB"].Value = "Hello World";

Console.WriteLine(dict["one"].Value);
Console.WriteLine(dict["one"]["two"]["three"].Value);
Console.WriteLine(dict["FieldA"]["FieldB"].Value);

OriginalL'auteur series0ne

L'original Dictionary objet COM qui a été créé pour travailler avec vb6 répondrait à une tentative d'accès à un non-existant élément par la création d'un nouvel élément de type Dictionary avec le nom correspondant. Cette approche permet à quelque chose pour être stocké à MyDict["Foo"]["Bar"] sans avoir à d'abord créer MyDict["Foo"]. Le problème avec cette approche est que si on souhaite ajouter "Foo" à MyDict lors de l'exécution d'une écriture MyDict["Foo"]["Bar"], on serait plutôt de ne pas créer un tel article si l'on tentait, par exemple évaluer MyDict["Foo"]["Bar"].ValueOrDefault(someDefaultValue).

J'ai utilisé de telles collections, car ils peuvent être utiles pour la modélisation de certaines choses (conceptuellement, elles ressemblent beaucoup aux documents XML). Une approche possible est de déclarer que les dictionnaires qui ne contiennent rien, mais d'autres dictionnaires sont considérés comme sémantiquement comme des non-entités qui peut être retirée à toute occasion. Lorsque implicitement l'ajout d'un sous-groupe, définir un indicateur dans l'élément auquel il est ajouté, indiquant qu'il doit être vérifié pour les articles qui peuvent être supprimés (ou de conserver un compteur du nombre de ces éléments peuvent exister). Puis, avec une certaine fréquence raisonnable, de balayer à travers les dictionnaires et supprimer ces "morts" éléments.

Une approche alternative est d'avoir l'index à partir du dictionnaire de ne pas retourner un élément réel, mais au lieu de retourner un "éphémère indexeur" type, qui conserve une référence à l'objet parent et a des méthodes internes GetNestedForReading, SetNestedForReading, GetValue, et SetValue, qui dos de la chaîne d'elle. Une déclaration Foo["Bar"]["Boz"] = "George"; va finir de le remplir efficacement Foo.SetNestedForReading("Bar").SetValue("Boz", "George"); tout z = Foo["Bar"]["Boz"]; effectue Foo.GetNestedForReading("Bar").GetValue("Boz");. L'appel de SetNestedForReading méthode avec un inexistante clé permettra de créer et de renvoyer un nouvel élément imbriqué; la GetNestedForReading méthode immuable "vide" de l'élément. En utilisant cette approche permettra ainsi d'éviter de créer des éléments vides.

Bien que cette dernière approche est plus compliqué que l'ancien, il a un autre avantage. Il est possible d'avoir chaque nœud individuellement tenir sa collection d'une salle de profondément immuable dictionnaire ou un partage de mutables; si l'un GetNestedForWriting appel voit que l'objet imbriqué est immuable, il est possible de construire une nouvelle plate-mutable objet possédant les mêmes éléments. Si on définit la méthode de clonage pour une mutable nœud de la création d'un nouveau immuable nœud (immuable) des clones de tous les sous-nœuds, et la méthode de clonage de immuable nœud que le retour lui-même, le clonage des arbres qui sont pour la plupart immuable devient très bon marché. Si on avait un nouveau-cloné (donc immuable) à quatre niveaux de l'arbre avec seize points à chaque niveau (de 65 536 nœuds feuilles au total) et de tous les nœuds ont été partagés immuable, la mise à jour d'un nœud feuille n'aurait besoin que de remplacer une feuille et quatre autres nœuds avec mutable ceux. Le clonage de l'arbre n'aurait besoin que de créer de nouveaux objets immuables pour les nœuds qui ont été remplacés par mutable (p. ex. copie de cinq choses). Même si on peut avoir la commodité d'une mutable arbre, on aurait les avantages d'efficacité de l'immuable.

Le plus gros "problème" que je vois avec cette approche est que pour éviter certains comportements bizarres il faut exiger l'utilisation de la syntaxe comme MyDict["Foo"]["Bar"].Value = "George". Si la conversion implicite opérateurs ont été utilisés pour échapper à cette obligation, quelqu'un pourrait s'attendre à une déclaration comme var st = MyThing["Foo"]["Bar"]; de définir st comme un string instantané de ce que MyThing["Foo"]["Bar"] détient, à ce moment-là; au contraire, elle le définir comme quelque chose qui va de l'indice de MyThing["Foo"]["Bar"]. Si l'on devait utiliser .Value de lire ou d'écrire des chaînes de ce type, du fait que la variable n'était pas une chaîne apparente. Si on a utilisé implicite opérateurs pour permettre à ce type de missions, le comportement serait bizarre. C'est dommage qu'il n'y aucun moyen d'une fonction peut spécifier "ne permettent pas de valeur de retour pour être utilisé pour l'inférence de type".

D'ailleurs, il est possible d'avoir l'indexeur le type d'une classe ou d'un générique struct. Si c'est une classe, un accès à foo["Bar"]["boz"]["baz"]... imbriquée N profonde nécessiterait la création de N temporaire tas d'objets. Si c'est un générique de struct, elle entraînera la création de N les structures, mais le plus profondément imbriquées les structures permettrait d'obtenir un plus grand. Pour des niveaux raisonnables de nidification, générique structs serait probablement un peu plus efficace, mais les classes serait probablement plus facile de travailler avec.

OriginalL'auteur supercat

Utiliser un Dictionary comme TValue:

var dict2 = new Dictionary<string, Dictionary<string, string>>();
var dict3 = new Dictionary<string, Dictionary<string, Dictionary<string, string>>>();

par exemple:

var dict =
    new Dictionary<string, Dictionary<string, string>>
        {
            {
                "F1", new Dictionary<string, string>
                            {
                                {"F2", "foo"}
                            }
                }
        };


dict["F1"]["F2"] = "bar";

OriginalL'auteur Ria