surcharge [] [] dans C#

Question

Je construis une structure de données arborescente et surchargée [] pour que je puisse dire

node["key1", "key2", "key3"] 

qui retourne le nœud dont les parents 1, 2 et 3 niveaux au-dessus sont les nœuds avec ces clés. les noeuds carte conceptuelle à un tableau de données, donc ce que j'ai maintenant cette fonction:

node[keys...].SetValue(i, value) 

qui définit la valeur i-ième données du nœud. ce qui serait bien est si je pouvais le faire:

node[keys][i] = value 

problème est

, nœud [clés] renvoie un noeud, de sorte que l'indexation [i] tente d'obtenir à un autre nœud. fondamentalement ce que je veux être capable de faire est de surcharger "[] []" en tant qu'opérateur, ce que je ne peux pas.

Y a-t-il un moyen de savoir ce que j'essaie de faire?

Answer 1

Remarque: Cette réponse parle de l'implémentation de quelque chose comme obj[a][b][c]... qui pourrait fonctionner avec un nombre variable de parenthèses. Il semble que ce n'est pas exactement ce que l'OP voulait.

Vous ne pouvez pas surcharger cela directement. Vous devriez retourner un objet avec un indexeur du premier indexeur afin que vous puissiez simuler cette fonctionnalité.
Il est un peu plus difficile à simuler set mais il est possible de faire quelque chose comme:

public class Node<T> { 
    public Node<T> this[string key] { 
     get { return GetChildNode(key); } 
     set { 
      if (value is DummyNode<T>) { 
       GetChildNode(key).Value = value.Value; 
      } else { 
       // do something, ignore, throw exception, depending on the problem 
      } 
     } 
    } 
    public static implicit operator T(Node<T> value) { 
     return value.Value; 
    } 
    private class DummyNode<T> : Node<T> { 
    } 
    public static implicit operator Node<T>(T value) { 
     return new DummyNode<T> { Value = value }; 
    } 
    public T Value { get; set; } 
} 

Answer 2

Je semble juste besoin de bricoler un peu plus pour le comprendre ... J'ai créé une deuxième surcharge:

public object this[int index] 
{ 
    set { ... } 
} 

qui me permet maintenant faire

node["child1", "child1's child1"][i] = value 

:)

Answer 3

var pat = new Tree<string[]>(); 
pat["test", "test2", "test3"] = new[] { "test3" }; 
Console.WriteLine(pat["test", "test2", "test3"][0]); 

cours de magie sont amusants ...

public class Tree<T> 
{ 
    private Dictionary<string, T> _store = new Dictionary<string, T>(); 

    private string GetKey(string[] index) 
    { 
     if (index == null || index.Length == 0) return string.Empty; 
     return string.Join(".", index); 
    } 

    public T this[params string[] index] 
    { 
     get 
     { 
      var key = GetKey(index); 
      if (!_store.ContainsKey(key)) 
       return default(T); 
      return _store[key]; 
     } 
     set 
     { 
      var key = GetKey(index); 
      if (_store.ContainsKey(key)) 
       _store.Remove(key); 
      if (value != null) 
       _store.Add(key, value); 
     } 
    } 
}