Un dizionario annidato in profondità è un antipattern?

Question

Mi hanno una struttura che può essere facilmente rappresentato utilizzando un dizionario nidificato tre profondo, in questo modo

private static Dictionary<string, Dictionary<string, Dictionary<string,string>>> PrerenderedTemplates; 

Qualora la struttura potrebbe essere usato qualcosa di simile

PrerenderedTemplates[instanceID][templategroup][templatepart] 

Ora, mi rendo conto che questo codice è difficile da leggere, perché guardando la definizione di definizione, non si può dire per cosa viene usato. L'unico vantaggio che posso davvero vedere nel modificarlo in Dictionary<string, PrerenderedTemplate> è la leggibilità. La conversione di ogni nidificazione in una propria classe (ad esempio class PrerenderedTemplate{} class TemplateGroup{} class TemplatePart{}) aggiungerebbe molte più righe di codice per un vantaggio computazionale piccolo (se non nullo). Per quanto posso vedere.

• Quindi, è il mio approccio "ok" o dovrei fare il miglio supplementare e creare classi separate?
• Va bene illustrare come funziona il nidificato Dictionary nella documentazione/commenti
• Esiste una procedura ottimale per gestire questo tipo di nidificazione?
• Tenete a mente, questo è un membro privato, non deve essere semplice per le persone che usano la classe.

Aggiornamento

Così, ispirato da Reza, ma in grado di utilizzare tuple, ho deciso di creare il mio generatore di chiavi e mettere in atto il suo modello come questo:

private Dictionary<string, string> PrerenderedTemplates; 
private string GetPrerenderedTemplateKey(string InstanceId, string FeatureId, string OptionId) 
{ 
    return new StringBuilder(instanceId) 
    .Append(FormatTools.LIST_ENTRY_DELIMITER) 
    .Append(templategroup) 
    .Append(FormatTools.LIST_ENTRY_DELIMITER) 
    .Append(templatepart).ToString(); 
} 

Dove FormatTools.LIST_ENTRY_DELIMITER è il carattere di uso privato Unicode 0xe04d.

Answer 1

Offro un'altra scelta:

Dictionary<Tuple<string, string, string>, string> pt; 

accesso al dizionario:

pt[Tuple.Create("id","group","part")] 

Answer 2

vorrei creare un dizionario personalizzato. Qualcosa di simile

public class TrippleKeyDict 
{ 
    private const string Separator = "<|>"; 
    private Dictionary<string, string> _dict = new Dictionary<string, string>(); 

    public string this[string key1, string key2, string key3] 
    { 
     get { return _dict[GetKey(key1, key2, key3)]; } 
     set { _dict[GetKey(key1, key2, key3)] = value; } 
    } 

    public void Add(string key1, string key2, string key3, string value) 
    { 
     _dict.Add(GetKey(key1, key2, key3), value); 
    } 

    public bool TryGetValue(string key1, string key2, string key3, out string result) 
    { 
     return _dict.TryGetValue(GetKey(key1, key2, key3), out result); 
    } 

    private static string GetKey(string key1, string key2, string key3) 
    { 
     return String.Concat(key1, Separator, key2, Separator, key3); 
    } 
} 

Se si pensa, concatenando le stringhe non è abbastanza sicuro, perché le chiavi potrebbero contenere i separatori, quindi utilizzare il proprio tipo di chiave o un Touple<string,string,string> come chiave. Poiché questo dettaglio di implementazione è nascosto all'interno del dizionario personalizzato, puoi modificarlo in qualsiasi momento.

È possibile utilizzare il dizionario come questo

var dict = new TrippleKeyDict(); 

// Using the Add method 
dict.Add(instanceID, templategroup, templatepart, "some value"); 

// Using the indexer 
dict[instanceID, templategroup, templatepart] = "xy"; 
string result = dict[instanceID, templategroup, templatepart]; 

// Using the TryGetValue method 
if (dict.TryGetValue(instanceID, templategroup, templatepart, out result)) { 
    // Do something with result 
} 

Answer 3

vorrei offrire un approccio alternativo, utilizzando un SortedDictionary e un operatore di confronto personalizzato:

public class PrerenderedTemplate 
    { 
     public string instanceID; 
     public string templategroup; 
     public string templatepart; 

     public PrerenderedTemplate(string id, string tempGroup, string tempPart) 
     { 
      instanceID = id; 
      templategroup = tempGroup; 
      templatepart = tempPart; 
     } 

     // custom comparer instance used as argument 
     // to SortedDictionary constructor 
     public class Comparer : IComparer<PrerenderedTemplate> 
     { 
      public int Compare(PrerenderedTemplate x, PrerenderedTemplate y) 
      { 
       int compare = 0; 
       if (compare == 0) compare = x.instanceID.CompareTo(y.instanceID); 
       if (compare == 0) compare = x.templategroup.CompareTo(y.templategroup); 
       if (compare == 0) compare = x.templatepart.CompareTo(y.templatepart); 
       return compare; 
      } 
     } 
    } 

Viene utilizzato in questo modo:

var dictionary = new SortedDictionary<PrerenderedTemplate, string>(new PrerenderedTemplate.Comparer()); 

    dictionary.Add(new PrerenderedTemplate("1", "2", "3"), "123"); 
    dictionary.Add(new PrerenderedTemplate("4", "5", "6"), "456"); 
    dictionary.Add(new PrerenderedTemplate("7", "8", "9"), "789"); 

    Assert.AreEqual<string>(dictionary[new PrerenderedTemplate("7", "8", "9")], "789"); 

Reza La risposta di Arab è adatta allo scopo ma personalmente non amo Tuples sulla base delle loro proprietà ambigue e della sintassi dettagliata.

Una classe personalizzata con il comparatore offre maggiore chiarezza e flessibilità, nel caso in cui le esigenze cambino.