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

Question

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

我知道字典是通用类型的线性映射：

对于每个 x（key），可能有 ay（value）

我需要的是多维映射：

对于每个 x,y（key），可能有 az（value）

但当然最重要的是我需要它支持通用类型并动态调整大小。

C# 中是否存在此数据结构，或者我是否必须创建字典的字典？如果没有必要，我宁愿不重新发明轮子。

---

重新发明轮子：

using System;
using System.Collections.Generic;
using System.Text;

namespace zlib.Collections
{
    public class Dictionary3D<Tx, Ty, Tz>
    {
        private Dictionary<Tuple<Tx, Ty>, Tz> _dict = new Dictionary<Tuple<Tx, Ty>, Tz>();

        public void Add(Tx x, Ty y, Tz z)
        {
            _dict.Add(Tuple.Create<Tx, Ty>(x, y), z);
        }

        public void Clear()
        {
            _dict.Clear();
        }

        public bool ContainsKey(Tx x, Ty y)
        {
            return _dict.ContainsKey(Tuple.Create<Tx, Ty>(x, y));
        }

        public bool ContainsValue(Tz z)
        {
            return _dict.ContainsValue(z);
        }

        public Dictionary<Tuple<Tx, Ty>, Tz>.Enumerator GetEnumerator()
        {
            return _dict.GetEnumerator();
        }

        public bool Remove(Tx x, Ty y)
        {
            return _dict.Remove(Tuple.Create<Tx, Ty>(x, y));
        }

        public bool TryGetValue(Tx x, Ty y, out Tz z)
        {
            return _dict.TryGetValue(Tuple.Create<Tx, Ty>(x, y), out z);
        }

        public int Count
        {
            get { return _dict.Count; }
        }

        public Dictionary<Tuple<Tx,Ty>,Tz>.KeyCollection Keys
        {
            get
            {
                return _dict.Keys;
            }
        }

        public Dictionary<Tuple<Tx, Ty>, Tz>.ValueCollection Values
        {
            get
            {
                return _dict.Values;
            }
        }

        public Tz this[Tx x, Ty y]
        {
            get
            {
                return _dict[Tuple.Create<Tx, Ty>(x, y)];
            }
            set
            {
                _dict[Tuple.Create<Tx, Ty>(x, y)] = value;
            }
        }
    }
}

似乎重新发明轮子在回应中胜出。这是我到目前为止想出的代码，但我觉得应该有更好的方法，比如矩阵之类的。

Answer 1

又怎么样

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

？

Answer 2

如果我没理解错的话，这就是您所需要的：

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;

是的，评论中提到的，您必须在该 Key 类中实现 HashCode 和 Equals。

Answer 3

如果您使用 Tuple，Chuck Jazdzewski 不久前写的 PolyDictionary 可能会满足您的需求。作为钥匙。实际上，它只是 Dictionary

• PolyDictionary
• <一个href="http://www.removingalldoubt.com/PermaLink.aspx/195f76e3-a734-4502-8fd6-6d2e49f2e4e3" rel="nofollow">PolyDictionary II：构造键
• PolyDictionary III：抛弃
• PolyDictionary IV：扩展

Answer 4

Tuple 可能是您想要的：

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

或者对于泛型：

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

对于 Tuple 参考一下 这里

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

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

作为参考，请查看 此处

Answer 5

怎么样：

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

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

我想答案意味着如果你想要一个干净的解决方案，你（或其他人）可能必须重新发明轮子。

Answer 6

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

参见Joshua bloch 在这种情况下，你基本上可以存储任何类型作为键。但是您也可以限制它。