深层嵌套字典是反模式吗？

Question

我有一个可以使用三深嵌套的字典中很容易表示的结构，像这样

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

凡结构可用于这样的事情

PrerenderedTemplates[instanceID][templategroup][templatepart] 

现在，我才知道这段代码很难阅读，因为从查看定义语句，你不能说出它的用途。我可以真正看到将其更改为Dictionary<string, PrerenderedTemplate>的唯一优点是可读性。将每个嵌套转换为它自己的类（例如class PrerenderedTemplate{} class TemplateGroup{} class TemplatePart{}）会为很少（如果有的话）计算优势添加更多的代码行。据我所见。

• 那么，我的方法是“好的”，还是应该多走一步并创建单独的课程？
• 可以包括嵌套的Dictionary如何在文档/注释中工作
• 是否有处理这种嵌套的最佳做法？
• 请记住，这是一名私人会员，对于使用该课程的人而言，并不需要简单。

更新

因此，由礼启发，但无法使用元组，我决定创建自己的密钥生成器和执行他的模式是这样的：

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(); 
} 

哪里FormatTools.LIST_ENTRY_DELIMITER是Unicode专用字符0xe04d。

Answer 1

我提供了另一种选择：

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

访问词典：

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

Answer 2

我想创建一个自定义词典。这样

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); 
    } 
} 

的东西，如果你认为，串联字符串是不够安全，因为键可以包含分离，然后使用自己的密钥类型或Touple<string,string,string>关键。由于此实现细节隐藏在自定义词典中，因此您可以随时更改它。

您可以使用字典这样

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

我想提供另一种方法，使用SortedDictionary和自定义比较：

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; 
      } 
     } 
    } 

是使用像这样：

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阿拉伯的答案是适合的目的，但我个人不喜欢元组的基础上它们的模棱两可的属性和冗长的语法。

与比较器的定制类提供了更清晰，也灵活，应任何要求的变化。