C# 我应该使用什么数据结构？

我有一个问题，我需要将两个输入映射到一个输出

我知道字典是一般类型的线性映射：

对于每个x（

键

），可能有一个y（

值

）

我需要的是多维映射：

对于每个x，y（

键

）可能有一个z（

值

）

当然，关键是我需要它来支持泛型类型和动态调整大小

这个数据结构是否存在于C#中，或者我必须创建一个字典字典？如果不需要的话，我宁愿不重新发明轮子

---

重塑车轮：

使用系统；
使用System.Collections.Generic；
使用系统文本；
命名空间zlib.Collections
{
公共类字典3d
{
专用词典_dict=新词典（）；
公共无效添加（Tx x、Ty y、Tz z）
{
_dict.Add（Tuple.Create（x，y），z）；
}
公共空间清除（）
{
_格言（Clear）；
}
公共图书馆集装箱（德克萨斯州x，Ty-y）
{
返回_dict.ContainsKey（Tuple.Create（x，y））；
}
公共布尔值（Tz）
{
返回_dict.ContainsValue（z）；
}
public Dictionary.Enumerator GetEnumerator（）
{
返回_dict.GetEnumerator（）；
}
公共布尔删除（Tx x，Ty y）
{
返回_dict.Remove（Tuple.Create（x，y））；
}
公共布尔TryGetValue（Tx x，Ty y，out Tz z）
{
返回_dict.TryGetValue（Tuple.Create（x，y），out z）；
}
公共整数计数
{
获取{return\u dict.Count；}
}
public Dictionary.KeyCollection密钥
{
得到
{
返回dict.key；
}
}
public Dictionary.ValueCollection值
{
得到
{
返回指定值；
}
}
公共Tz本[Tx x，Ty y]
{
得到
{
返回_dict[Tuple.Create（x，y）]；
}
设置
{
_dict[Tuple.Create（x，y）]=值；
}
}
}
}

---

看来，重新发明轮子似乎正在赢得众多回应。这是我到目前为止提出的代码，但我觉得应该有更好的方法，比如

矩阵

或其他东西。

如果我没弄错，这就是您需要的：

class Key<Tx, Ty>
{
    public Tx x;
    public Ty y;

    public Key(Tx x, Ty y)
    {
        this.x = x;
        this.y = y;
    }
}

Dictionary<Key<Tx, Ty>, Tz> d;

类密钥
{
公共Tx x；
公共卫生；
公钥（Tx x，Ty y）
{
这个.x=x；
这个。y=y；
}
}
词典d；

是的，在注释中提到，您必须在该键类中实现HashCode和Equals。

如何

   Dictionary<Tuple<T,K>,Tuple<L,J>> 

字典

---

？？元组可能就是您想要的：

var population = new Tuple< string, int>("New York", 7891957);

var population=newtuple（“纽约”，7891957）；

或对于非专利药：

var population = new Tuple< S, T>("New York", 7891957);

var population=newtuple（“纽约”，7891957）；

对于元组，请参阅

此外，如果您想要词典的用户词典，您可以这样做：

using DictOfDict = Dictionary< X, Dictionary< Y, Z>> ;

使用DictOfDict=Dictionary；

---

参考一下

我认为您需要一个类型安全的异构容器，它由一个字典支持。在这种情况下，您必须重写IDictionary并拥有自己的impl。不幸的是，除非你遵循其他答案或找到一个工作，否则你没有可以使用的课程

---

在本例中，基本上可以将任何类型存储为键。不过，你也可以限制它。

恰克·贾兹兹维斯基（Chuck Jazdzewski）不久前写的PolyDictionary可能会得到你想要的，如果你使用元组作为键的话。真的，这只是一本字典的包装，但它确实起到了作用。查看他关于以下主题的博客系列：

这个怎么样：

class Dict3D
{
    private Dictionary<KeyValuePair<object,object>, object> innnerDict= new Dictionary<KeyValuePair<object,object>, object>();

    public object Get(object key1, object key2)
    {
        KeyValuePair<object,object> bigKey = new KeyValuePair<object, object>(key1, key2);
        if (innnerDict.ContainsKey(bigKey))
        {
            return innnerDict[bigKey];
        }
        return null;
    }

    public void Set(object key1, object key2, object somevalue)
    {
        KeyValuePair<object, object> bigKey = new KeyValuePair<object, object>(key1, key2);
        if (innnerDict.ContainsKey(bigKey))
        {
            innnerDict[bigKey] = somevalue;
        }
        else
        {
            innnerDict.Add(bigKey, somevalue);
        }
    }
}

类Dict3D
{
私有字典innnerDict=新字典（）；
公共对象获取（对象键1、对象键2）
{
KeyValuePair bigKey=新的KeyValuePair（键1、键2）；
if（innnerDict.ContainsKey（bigKey））
{
返回InnerDict[bigKey]；
}
返回null；
}
公共无效集（对象键1、对象键2、对象值）
{
KeyValuePair bigKey=新的KeyValuePair（键1、键2）；
if（innnerDict.ContainsKey（bigKey））
{
innnerDict[bigKey]=somevalue；
}
其他的
{
Add（bigKey，somevalue）；
}
}
}

您也可以将其设置为通用版本，但这是一个简单的版本

---

我猜答案意味着，如果您想要一个干净的解决方案，您（或其他人）可能必须重新发明轮子。
x和y的键类型是否相同？你能解释一下你怎么需要一个键的通用类型吗？异构密钥？@DarthVader，密钥的类型在某些情况下可能是相同的，但不会总是相同的。我想我还应该指定，密钥的类型将特定于多维对象的实例。理想情况下，我能够编写

newdictionary3d（）并使其与新字典3D（）一样工作，哎哟，很抱歉，我不知道。在创建了一个充当包装器的自定义类之后，我觉得创建新的
元组所需的一点点代码实在不值得。
class Dict3D
{
    private Dictionary<KeyValuePair<object,object>, object> innnerDict= new Dictionary<KeyValuePair<object,object>, object>();

    public object Get(object key1, object key2)
    {
        KeyValuePair<object,object> bigKey = new KeyValuePair<object, object>(key1, key2);
        if (innnerDict.ContainsKey(bigKey))
        {
            return innnerDict[bigKey];
        }
        return null;
    }

    public void Set(object key1, object key2, object somevalue)
    {
        KeyValuePair<object, object> bigKey = new KeyValuePair<object, object>(key1, key2);
        if (innnerDict.ContainsKey(bigKey))
        {
            innnerDict[bigKey] = somevalue;
        }
        else
        {
            innnerDict.Add(bigKey, somevalue);
        }
    }
}