在 C# 中创建嵌套字典的优雅方式

Question

我意识到我没有提供足够的信息让大多数人读懂我的想法并理解我的所有需求，所以我在原来的基础上做了一些改动。

假设我有一个这样的类的项目列表：

public class Thing
{
    int Foo;
    int Bar;
    string Baz;
}

我想根据 Foo 的值对 Baz 字符串进行分类，然后是 Bar。对于 Foo 和 Bar 值的每种可能组合，最多会有一个 Thing，但我不保证每个都有一个值。将其概念化为表格的单元格信息可能会有所帮助：Foo 是行号，Bar 是列号，Baz 是要在那里找到的值，但不一定每个单元格都有一个值。

IEnumerable<Thing> things = GetThings();
List<int> foos = GetAllFoos();
List<int> bars = GetAllBars();
Dictionary<int, Dictionary<int, string>> dict = // what do I put here?
foreach(int foo in foos)
{
    // I may have code here to do something for each foo...
    foreach(int bar in bars)
    {
        // I may have code here to do something for each bar...
        if (dict.ContainsKey(foo) && dict[foo].ContainsKey(bar))
        {
            // I want to have O(1) lookups
            string baz = dict[foo][bar];
            // I may have code here to do something with the baz.
        }
    }
}

生成嵌套字典的简单、优雅的方法是什么？我使用 C# 的时间已经够长了，以至于我已经习惯于为所有此类常见问题寻找简单的单行解决方案，但这个解决方案让我很困惑。

Answer 1

这是一个使用 Linq 的解决方案：

Dictionary<int, Dictionary<int, string>> dict = things
    .GroupBy(thing => thing.Foo)
    .ToDictionary(fooGroup => fooGroup.Key,
                  fooGroup => fooGroup.ToDictionary(thing => thing.Bar,
                                                    thing => thing.Baz));

Answer 2

一种优雅的方法是不自己创建字典，而是使用 LINQ GroupBy 和 ToDictionary 为您生成它。

var things = new[] {
    new Thing { Foo = 1, Bar = 2, Baz = "ONETWO!" },
    new Thing { Foo = 1, Bar = 3, Baz = "ONETHREE!" },
    new Thing { Foo = 1, Bar = 2, Baz = "ONETWO!" }
}.ToList();

var bazGroups = things
    .GroupBy(t => t.Foo)
    .ToDictionary(gFoo => gFoo.Key, gFoo => gFoo
        .GroupBy(t => t.Bar)
        .ToDictionary(gBar => gBar.Key, gBar => gBar.First().Baz));

Debug.Fail("Inspect the bazGroups variable.");

我假设通过使用Foo 和Bar 对Baz 进行分类，您的意思是如果两个事物同时具有Foo 和Bar 等于那么它们的Baz 值也相同。如果我错了，请纠正我。

您基本上是由Foo 属性分组的...
然后对于每个结果组，您在 Bar 属性上进行分组...
然后对于每个结果组，您将第一个 Baz 值作为字典值。

如果您注意到，方法名称与您尝试执行的操作完全匹配。 :-)

---

编辑：这是使用查询理解的另一种方式，它们更长，但更容易阅读和理解：

var bazGroups =
    (from t1 in things
     group t1 by t1.Foo into gFoo
     select new
     {
         Key = gFoo.Key,
         Value = (from t2 in gFoo
                  group t2 by t2.Bar into gBar
                  select gBar)
                  .ToDictionary(g => g.Key, g => g.First().Baz)
     })
     .ToDictionary(g => g.Key, g => g.Value);

不幸的是，ToDictionary 没有对应的查询理解，因此它不如 lambda 表达式优雅。

...

希望这会有所帮助。

Answer 3

定义您自己的自定义泛型NestedDictionary 类

public class NestedDictionary<K1, K2, V>: 
     Dictionary<K1, Dictionary<K2, V>> {}

然后在你编写的代码中

NestedDictionary<int, int, string> dict = 
       new NestedDictionary<int, int, string> ();

如果你经常使用 int、int、string one，也可以为它定义一个自定义类..

   public class NestedIntStringDictionary: 
        NestedDictionary<int, int, string> {}

然后写：

  NestedIntStringDictionary dict = 
          new NestedIntStringDictionary();

编辑：添加从提供的项目列表构造特定实例的能力：

   public class NestedIntStringDictionary: 
        NestedDictionary<int, int, string> 
   {
        public NestedIntStringDictionary(IEnumerable<> items)
        {
            foreach(Thing t in items)
            {
                Dictionary<int, string> innrDict = 
                       ContainsKey(t.Foo)? this[t.Foo]: 
                           new Dictionary<int, string> (); 
                if (innrDict.ContainsKey(t.Bar))
                   throw new ArgumentException(
                        string.Format(
                          "key value: {0} is already in dictionary", t.Bar));
                else innrDict.Add(t.Bar, t.Baz);
            }
        }
   }

然后写：

  NestedIntStringDictionary dict = 
       new NestedIntStringDictionary(GetThings());

Answer 4

另一种方法是使用基于 Foo 和 Bar 值的匿名类型来键入您的字典。

var things = new List<Thing>
                 {
                     new Thing {Foo = 3, Bar = 4, Baz = "quick"},
                     new Thing {Foo = 3, Bar = 8, Baz = "brown"},
                     new Thing {Foo = 6, Bar = 4, Baz = "fox"},
                     new Thing {Foo = 6, Bar = 8, Baz = "jumps"}
                 };
var dict = things.ToDictionary(thing => new {thing.Foo, thing.Bar},
                               thing => thing.Baz);
var baz = dict[new {Foo = 3, Bar = 4}];

这有效地将您的层次结构扁平化为一个字典。 请注意，此字典不能对外公开，​​因为它是基于匿名类型的。

如果 Foo 和 Bar 值组合在您的原始集合中不是唯一的，那么您需要先将它们分组。

var dict = things
    .GroupBy(thing => new {thing.Foo, thing.Bar})
    .ToDictionary(group => group.Key,
                  group => group.Select(thing => thing.Baz));
var bazes = dict[new {Foo = 3, Bar = 4}];
foreach (var baz in bazes)
{
    //...
}

Answer 5

您可以在您定义的地方使用KeyedCollection：

class ThingCollection
    : KeyedCollection<Dictionary<int,int>,Employee>
{
    ...
}

Answer 6

使用 BeanMap 的两个关键 Map 类。还有一个 3 键映射，如果您需要 n 个键，它是相当可扩展的。

http://beanmap.codeplex.com/

您的解决方案将如下所示：

class Thing
{
  public int Foo { get; set; }
  public int Bar { get; set; }
  public string Baz { get; set; }
}

[TestMethod]
public void ListToMapTest()
{
  var things = new List<Thing>
             {
                 new Thing {Foo = 3, Bar = 3, Baz = "quick"},
                 new Thing {Foo = 3, Bar = 4, Baz = "brown"},
                 new Thing {Foo = 6, Bar = 3, Baz = "fox"},
                 new Thing {Foo = 6, Bar = 4, Baz = "jumps"}
             };

  var thingMap = Map<int, int, string>.From(things, t => t.Foo, t => t.Bar, t => t.Baz);

  Assert.IsTrue(thingMap.ContainsKey(3, 4));
  Assert.AreEqual("brown", thingMap[3, 4]);

  thingMap.DefaultValue = string.Empty;
  Assert.AreEqual("brown", thingMap[3, 4]);
  Assert.AreEqual(string.Empty, thingMap[3, 6]);

  thingMap.DefaultGeneration = (k1, k2) => (k1.ToString() + k2.ToString());

  Assert.IsFalse(thingMap.ContainsKey(3, 6));
  Assert.AreEqual("36", thingMap[3, 6]);
  Assert.IsTrue(thingMap.ContainsKey(3, 6));
}

Answer 7

我认为最简单的方法是使用 LINQ 扩展方法。显然我还没有测试过这段代码的性能。

var items = new[] {
  new Thing { Foo = 1, Bar = 3, Baz = "a" },
  new Thing { Foo = 1, Bar = 3, Baz = "b" },
  new Thing { Foo = 1, Bar = 4, Baz = "c" },
  new Thing { Foo = 2, Bar = 4, Baz = "d" },
  new Thing { Foo = 2, Bar = 5, Baz = "e" },
  new Thing { Foo = 2, Bar = 5, Baz = "f" }
};

var q = items
  .ToLookup(i => i.Foo) // first key
  .ToDictionary(
    i => i.Key, 
    i => i.ToLookup(
      j => j.Bar,       // second key
      j => j.Baz));     // value

foreach (var foo in q) {
  Console.WriteLine("{0}: ", foo.Key);
  foreach (var bar in foo.Value) {
    Console.WriteLine("  {0}: ", bar.Key);
    foreach (var baz in bar) {
      Console.WriteLine("    {0}", baz.ToUpper());
    }
  }
}

Console.ReadLine();

输出：

1:
  3:
    A
    B
  4:
    C
2:
  4:
    D
  5:
    E
    F

Answer 8

Dictionary<int, Dictionary<string, int>> nestedDictionary = 
            new Dictionary<int, Dictionary<string, int>>();